DEV Community: Marcelo Michels

Utilizando Alias para produtividade no terminal

Marcelo Michels — Wed, 20 Oct 2021 00:12:47 +0000

Utilizar o terminal faz parte do dia a dia de todo programador, muitas vezes o uso desse terminal é para realizar ou executar quase sempre os mesmos comandos, alguns deles podem ser mais simples ou mais complexos. Desta forma, o quão bom seria possuirmos atalhos para esses comandos? Vamos ver abaixo como criar-los.

OBS: Todo esse post foi testado apenas no linux e macOS, não sei como é o funcionamento de algo parecido no windows.

Alias

O comando alias (apelido em português, eu particularmente também chamo de atalhos), permite definirmos um apelido para um determinado comando.

Podemos definir esse apelido dentro do arquivo .profile (dependendo do seu sitema operacional pode ser .bashrc, .zshrc ou algum similar) no diretório raiz de um usuário.

No meu caso vou editar o arquivo .zshrc e adicionar no final dele a linha abaixo.

alias ola="echo 'Isso foi impresso utilizando alias'"

Após editar e salvar o arquivo, no terminal digite o comando abaixo para que ele considere as ultimas alterações realizadas no arquivo.

source ~/.zshrc

Depois disso podemos testar se o apelido vai funcionar, então digite apenas ola no terminal para ver o que acontece, no meu caso o resultado foi o mostrado abaixo.

mm@MacBook-Pro-de-Marcelo ~ % ola
Isso foi impresso utilizando alias

Pronto, já vimos na prática como criar um apelido para um determinado comando, mas agora vamos utilizar esses atalhos para coisas mais interessantes e uteis.

Atalhos git

Os atalhos que mais utilizo no meu terminal são do git, vou deixar abaixo todos eles, sendo que cada pessoa pode modificar os atalhos conforme o seu gosto.

alias gits="git status"
alias gita="git add --all"
alias gitc="git commit -m"
alias gitac="gita && gitc"
alias gitamend="gita && git commit --amend && git push -f"
alias gitp="git push"
alias gitacp="gitac \"push\" && gitp"
alias gitf="git fetch --all"
alias gitfp="gitf && git pull"
alias gitl="git log --pretty=format:'%C(yellow)%cr %C(cyan)%H %C(green)%an %C(blue)%d %C(white)%s'"
alias gitche="git checkout"
alias gitchemaster="git checkout master"
alias gitchedevelop="git checkout develop"
alias gitchenew="git checkout -b"
alias gitm="git merge"
alias gitdelbranchlocal="git branch -d"
alias gitdelbranchremote="git push origin --delete"
alias gitb="git branch -a"
alias gittag="git tag"
alias gittagpush="git push origin --tags"

Isso também ajuda para quando esquecemos de algum comando não precisar pesquisar por ele em outros lugares.

Atalhos npm

Outra ferramenta que utilizo bastante é o npm, desta forma também tenho uma série de atalhos para ele.

alias nr="npm run"
alias nrd="npm run dev"
alias nrt="nr test"
alias nrcopen="brave-browser coverage/lcov-report/index.html"
alias nrc="npm run test:coverage"
alias nrco="nrc && nrcopen"
alias covo="nrco"
alias nrb="nr build"
alias ns="npm start"
alias ni="npm install"
alias nu="npm uninstall"
alias npmrmi="rm -rf node_modules && rm -f package-lock.json && npm i"

Atalhos ssh

Sempre que preciso conectar em uma maquina ou servidor por ssh, preciso lembrar ou buscar qual o IP da maquina em algum outro lugar. Então também resolvi esse problema utilizando uma outra sessão de atalhos.

alias sshProjetoHomolog="ssh homologUser@192.168.1.100"
alias sshProjetoProd="ssh prodUser@192.168.1.101"
alias sshGitlab="ssh gitlabUser@192.168.1.102"

Atalhos VS Code e Docker

alias cdProjeto="cd ~/developer/projeto"
alias cdProjetoDocker="cdProjeto && cd scripts/docker"
alias cdProjetoFront="cdProjeto && cd projeto-frontend"
alias cdProjetoServer="cdProjeto && cd projeto-server"
alias cdProjetoWorker="cdProjeto && cd projeto-worker"

# Abre no vscode o projeto
alias projetoOpen="cdProjeto && code projeto.code-workspace"

# Build total ou parcial 
alias projetoBuild="cdProjetoDocker && docker-compose -f docker-compose.local.yml build --no-cache"
alias projetoBuildServer="projetoBuild projeto-server"
alias projetoBuildWorker="projetoBuild projeto-worker"

# Execução total ou parcial
alias projetoRun="cdProjetoDocker && docker-compose -f docker-compose.local.yml up"
alias projetoRunServer="projetoRun projeto-server"
alias projetoRunWorker="projetoRun projeto-worker"
alias projetoRunFront="cdProjetoFront && ns"

# Build and Run
alias projetoBuildAndRun="cdProjetoDocker && projetoBuild && projetoRun"

# stop
alias projetoStop="cdProjetoDocker && docker-compose -f docker-compose.local.yml down"

compare a enorme diferença entre digitar todos os comandos na mão

cd ~/developer/projeto/scripts/docker
docker-compose -f docker-compose.local.yml build --no-cache
# Esperar a build terminar
docker-compose -f docker-compose.local.yml up

Substiindo todos os comandos acima por um atalho:

projetoBuildAndRun

As vezes o tempo de espera é o maior vilão, pois enquando gera a build vc vai pro navegador ou pra caixa de e-mails e quando volta terminal esta ocioso esperando pelo próximo comando.

Pode bater o enter e ir fazer um café e quando voltar tudo vai estar OK, sem perca de tempo com terminal ocioso na espera pelo próximo comando.

Dica extra

Eu mantenho um repositório privado no meu github com alguns comandos de setup e instação, para quando eu formatar minha maquina possa buscar esses comandos e scripts de uma forma bem rápida. Também passei a adicionar dentro desse repositório um arquivo que contem todos os meus alias, desta forma eu apenas importo o arquivo .myCustomAlias de dentro do meu repositório lá no arquivo .zshrc, para fazer essa importação basta adicionar a linha abaixo no arquivo .profile ou .zshrc.

source ~/path-to-my-repo/.myCustomAlias

Espero que tenha ajudado e inspirado vocês a criarem seus próprios atalhos, apelidos, aliases (como preferirem chamar).

Criando e restaurando backup no MongoDB

Marcelo Michels — Sun, 25 Apr 2021 19:59:40 +0000

Criando backup
Restaurando backup
Script para criar o backup e salvar no AWS S3
Conclusão

Criando backup

Para criar o backup precisamos estar em uma maquina com o Mongo instalado para ter acesso ao comando mongodump em nosso terminal. Com ele será possível fazer backup do próprio banco local ou de um banco remoto.

Criando o backup de todos os bancos existentes naquele servidor:

mongodump --uri "mongodb://mongodb0.example.com:27017" --gzip
# --uri  = string de conexão com o mongo  
# --gzip = indica que deseja gerar um backup compactado

Criando o backup de um banco de dados especifico:

mongodump --uri "mongodb://mongodb0.example.com:27017" --gzip -d nomedobanco
# --uri  = string de conexão com o mongo  
# --gzip = indica que deseja gerar um backup compactado
# -d     = nome de um determinado banco, qual deseja-se fazer o backup

O resultado do comando mongo mongodump criará uma pasta chamada dump dentro do diretório qual foi executado o comando (exceto caso seja especificado um outro caminho).

Existem mais opções que podem ser adicionadas ao comando mongodump na documentação oficial.

Restaurando backup

Para restaurar o backup criado na etapa anterior vamos utilizar o comando mongorestore passando a string de conexão seguida da pasta qual contem o conteúdo gerado pelo mongodump anteriormente.

Restaurando um backup com vários bancos

mongorestore --uri "mongodb://mongodb0.example.com:27017" --gzip ./dump/
# --uri  = string de conexão com o mongo
# --gzip = indica que deseja gerar um backup compactado

Restaurando um backup de um banco especifico

mongorestore --uri "mongodb://mongodb0.example.com:27017" --gzip ./dump/nomedobanco -d nomedobanco
# --uri  = string de conexão com o mongo
# --gzip = indica que deseja gerar um backup compactado
# -d     = nome de um determinado banco, qual deseja-se fazer o backup

Existem mais opções que podem ser adicionadas ao comando mongorestore na documentação oficial.

Script para criar o backup e salvar no AWS S3

Caso queira criar uma rotina de backup automatizado para executar o comando de backup periodicamente podemos criar um script para realizar essa tarefa.

Criar um arquivo shell script com o seguinte conteúdo:

mongodump --uri "mongodb://mongodb0.example.com:27017" --gzip
D=$(date '+%Y-%m-%d-%H')
zip -r $D.zip ./dump/
aws s3 cp $D.zip s3://<s3-bucket-name>/$D --profile michels
rm -rf ./dump/
rm -f $D.zip

No exemplo acima estamos realizando as seguintes instruções em cada linha:

Criar o backup do mongodb com mongodump.
Declarar variável chamada "D" que vai armazenar a data atual no padrão "ANO-MES-DIA-HORA".
Criar um .zip da pasta dump que foi criada no passo 1.
Copiar pra um bucket do S3 o .zip criado no passo 3.
1. Estou considerando que o aws cli já esteja instalado e configurado.
2. Fique a vontade para utilizar outro serviço para essa etapa.
Remover a pasta dump para não ficar lixo na pasta.
Remover o arquivo .zip criado para não ficar lixo na pasta.

Agora, caso esteja utilizando linux, basta adicionar uma chamada para esse script dentro do crontab da maquina.

Leia mais sobre crontab aqui, com ele é possível executar tarefas no seu terminal periodicamente de forma bem dinâmica e flexível.

Um exemplo seria executar o nosso script de backup todos os dias as 2hrs e as 14hrs. Para isso basta executar o comando crontab -e em seu terminal e editar o arquivo aberto adicionando uma nova linha com o conteúdo abaixo:

0 2,14 * * * cd /path/to/script/ && sh backup-mongo-to-s3.sh

Agora basta salvar o arquivo e quando chegar na hora configurada o arquivo backup-mongo-to-s3.sh será executado.

Conclusão

Neste post aprendemos criar e restaurar um backup do MongoDB, assim como agendar uma tarefa para executar esse backup periodicamente e salva-lo no S3 da AWS.

Instalando e configurando o MongoDB no Ubuntu

Marcelo Michels — Sat, 20 Feb 2021 18:44:22 +0000

Instalando o MongoDB
Criando usuários e definindo que queremos usar autenticação
- Definindo que queremos usar autenticação
- Criando um usuário mais restrito
- Alterando a senha de um usuário MongoDB

Para instalar o MongoDB em um servidor linux é muito fácil, porem precisamos configurar alguns itens de segurança antes de começar utiliza-lo em nossas aplicações.

Para seguir os passos abaixo vamos considerar que você já tenha uma maquina em execução com Ubuntu rodando.

Instalando o MongoDB

Vamos seguir uma sequencia de comandos para realizar a instalação seguindo a documentação oficial. Nos Links abaixo a versão do MongoDB fica explicita na URL utilizada, certifique-se de consultar a documentação acima pra copiar esses links sempre com a ultima versão disponível.

1 - Importe a chave pública usada pelo sistema de gerenciamento de pacotes.

wget -qO - https://www.mongodb.org/static/pgp/server-4.4.asc | sudo apt-key add -

2 - Crie um arquivo de lista para MongoDB.

echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/4.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.4.list

3 - Recarregue o banco de dados do pacote local.

sudo apt-get update

4 - Instale o pacote MongoDB.

sudo apt-get install -y mongodb-org

5 - Iniciar o serviço do MongoDB

sudo service mongod start

6 - Verifique se a instalação foi concluída e se o serviço ficou executando

sudo service mongod status
# Output
mongod.service - MongoDB Database Server
  Loaded: loaded (/lib/systemd/system/mongod.service; disabled; vendor preset: enabled)
  Active: active (running) since Sat 2021-02-20 11:14:01 -03; 39s ago
  Docs: https://docs.mongodb.org/manual
  Main PID: 14819 (mongod)
  Memory: 64.5M

7 - Você pode opcionalmente garantir que o MongoDB iniciará após uma reinicialização do sistema, emitindo o seguinte comando:

sudo systemctl enable mongod

Pronto, já temos nosso MongoDB rodando em nossa maquina, mas ainda está sem senha e sem usuários para autenticação. Caso essa instalação seja em uma maquina de desenvolvimento até aqui já é o suficiente para conectar nosso Robomongo (Client Desktop) ou nossa aplicação a ele. Mas caso essa instalação vai ser utilizada pra um ambiente de servidor (produção ou homologação) vamos precisar permitir acesso externo a ele e também cadastrar usuários para autenticação, que veremos logo em seguida.

Criando usuários e definindo que queremos usar autenticação

Na maquina que instalamos o MongoDB vamos abrir o terminal e executar mongo para acessar a interface de linha de comando do interna do MongoDB onde vai aparecer um prefixo >. Quando quiser sair deste terminal digite > exit.

Dentro da linha de comando do MongoDB vamos executar o comando abaixo para dizer em qual banco de dados queremos executar nossos comandos.

> use admin
# Output
switched to db admin

Agora vamos criar um usuário que chamado root com a senha root que tenha permissão total para realizar qualquer operação dentro do MongoDB.

> db.createUser({
    user: "root",
    pwd: "root",
    roles:[{ "role" : "root", "db" : "admin" }]
  });
// Output
Successfully added user: {...}

Definindo que queremos usar autenticação

Apenas criar o usuário não vai exigir que ele seja utilizado para acessar o MongoDB, precisamos alterar o arquivo de configuração para sinalizar que queremos utilizar autenticação.

# sair no terminal do mongo
> exit
# editar o arquivo de configuração no mongo
sudo nano /etc/mongod.conf

encontre a linha

#security:

e troque por

security:
  authorization: enabled

Caso queira acessar o MongoDB de outras maquinas já aproveite e troque a linha

  bindIp: 127.0.0.1

por

  bindIp: 0.0.0.0

Agora vamos reiniciar o serviço do MongoDB para considerar essas novas configurações

sudo service mongod restart

A partir de agora quando for conectar no nosso banco de dados mongodb://localhost:27017 sem passar usuário e senha não vamos mais conseguir. Mas caso utilize nosso usuário e senha vamos conseguir mongodb://root:root@localhost:27017/admin.
Note que uma string de conexão com MongoDB é composta da seguinte maneira mongodb://<usuario>:<senha>@localhost:27017/<banco-usado-na-criacao-usuario>

Criando um usuário mais restrito

Não queremos um usuário com permissão total ao MongoDB para utilizar-lo em nossa aplicação, então vamos criar um usuário que tenha acesso apenas a um determinado banco e que tenha apenas permissão de escrita e leitura. Leia mais sobre outras roles de acesso.

Vamos criar um usuário chamado app com a senha app.senha.123 que vai ter acesso apenas ao banco de dados meu-banco-1.

O primeiro passo vai ser autenticar-se em nosso usuário root (acesso completo)

> use admin
> db.auth("root","root");

Depois de autenticados dentro do banco admin devemos identificar qual o banco de dados queremos criar um novo usuário.

> use meu-banco-1

Agora sim podemos criar nosso usuário

> db.createUser({
    user: "app",
    pwd: "app.senha.123",
    roles : [{"role" : "readWrite", "db" : "meu-banco-1"}]
  });

Pronto, agora temos um usuário que tem acesso apenas pra leitura e gravação em apenas um determinado banco.

Alterando a senha de um usuário MongoDB

Para alterar a senha de um usuário MongoDB basta acessar o banco de dados qual ele pertence e executar db.changeUserPassword(<usuario>,<nova-senha>)

> use meu-banco-1
> db.changeUserPassword("app", "app.senha.456");

Por hoje é isso, em breve teremos mais posts sobre MongoDB, de como criar um backup automatizado do nosso banco e salvar esse backup em um bucket s3 da aws.

Operações de CRUD com MongoDB

Marcelo Michels — Sun, 07 Feb 2021 01:09:20 +0000

Inserindo documentos
- Inserindo um documento
- Inserindo vários documentos ao mesmo tempo
Buscando por documentos
- Buscando todos os documentos da coleção
- Buscando por algum campo especifico
- Definindo quais campos do documento queremos que sejam retornados
- Busca com paginação
- Buscando documentos com expressões regulares
- Buscando documentos a partir de informações de sub documentos
- Buscando documentos a partir de informações de sub listas
- Buscando documentos utilizando operador $in
Atualizando documentos
- Substituindo um documento inteiro
- Atualizando parte de um documento
- Atualizando muitos documentos
- Atualizando campo de um documento de forma incremental
- Atualizando sub lista de documento com novos registros
Deletando documentos
Conclusão

Gostaria de compartilhar com vocês e também para consulta própria no futuro, algumas das operações disponíveis no MongoDB para inserir, atualizar, buscar e deletar dados em coleções de documentos no MongoDB.

Vamos começar criando uma coleção de documentos chamada posts, onde vamos inserir alguns documentos que representam um post feito em um blog, depois vamos manipular suas informações.

// Input
db.createCollection("posts");
// Output
{
    "ok" : 1
}

Pronto, já temos nossa coleção chamada posts.

Inserindo documentos

Como estamos trabalhando com um banco de dados orientado a documentos, isso significa que cada registro em nosso banco é um documento. Esse documento basicamente é um JSON qual podemos adicionar nossas informações, incluindo sub documentos e sub listas de documentos. Lembrando que cada documento de uma coleção não pode passar de 16MB de dados. Também não pode ultrapassar 100 níveis de sub documentos.

Inserindo um documento

Vamos inserir um documento que representa nosso post do blog, utilizando a função insertOne.

// Input
db.posts.insertOne({
  title: "Introdução a banco de dados NoSQL",
  content: "...",
  categories: [ "database", "nosql", "mongodb"],
  author: { name: "Marcelo Michels", about: "..."},
  likes: 0
});
// Output
{
    "insertedId" : ObjectId("601ea27a4fb18f6b8e31fd3c")
}

A função insertOne retornou um insertedId que vai ser o identificador do nosso documento. Esse identificador que o MongoDB gerou automaticamente vai ficar salvo dentro de um campo do nosso documento chamado _id. Caso seja informado um campo chamado _id dentro do nosso JSON que estamos salvando, o MongoDB não vai gerar um novo valor para ele, e vai considerar a informação que estamos passando.

Inserindo vários documentos ao mesmo tempo

Também podemos inserir mais do que um documento ao mesmo tempo utilizando a função insertMany.

// Input
db.posts.insertMany([
  {
    title: "Introdução a Rust",
    content: "...",
    categories: ["languages", "rust"],
    author: { name: "Marcelo Michels", about: "..." },
    likes: 0,
  },
  {
    title: "Fazendo backup automatizado do MongoDB",
    content: "...",
    categories: ["database", "nosql", "mongodb", "infra"],
    author: { name: "Marcelo Michels", about: "..." },
    likes: 0,
  },
  {
    title: "Performance para páginas WEB",
    content: "...",
    categories: ["performance", "front-end"],
    author: { name: "Marcelo Michels", about: "..." },
    likes: 0,
  },
  {
    title: "Introdução a PWA",
    content: "...",
    categories: ["front-end", "pwa"],
    author: { name: "Joaquim Augusto Michels", about: "..." },
    likes: 0,
  },
]);
// Output
{
    "insertedIds" : [
        ObjectId("601ed2614fb18f6b8e31fd43"),
        ObjectId("601ed2614fb18f6b8e31fd44"),
        ObjectId("601ed2614fb18f6b8e31fd45"),
        ObjectId("601ed2614fb18f6b8e31fd46")
    ]
}

Buscando por documentos

Com alguns registros já inseridos na nossa coleção de posts, já podemos buscar as informações que tem nela. Abaixo veremos algumas das operações de buscas que temos.

Buscando todos os documentos da coleção

Para buscar todos os registros de uma coleção usaremos o a função find.

// Input
db.posts.find({});
// Output
[
  {
    "_id" : ObjectId("601ed2504fb18f6b8e31fd42"),
    "title" : "Introdução a banco de dados NoSQL",
    "content" : "...",
    "categories" : [ "database", "nosql", "mongodb" ],
    "author" : { "name" : "Marcelo Michels", "about" : "..." },
    "likes" : 0
  }
,
  ...
]
// colei aqui apenas a primeira linha do que foi retornado
// mas no total foram 5 documentos quais inserimos anteriormente

Podemos observar que dentro de cada documento temos o campo _id ObjectId que foi gerado automaticamente pelo MongoDB para cada registro

Buscando por algum campo especifico

Para buscar um documento a partir de alguma referencia que necessitamos basta passarmos um JSON para função find. Nesse JSON vamos passar apenas os campos quais queremos fazer a busca, no exemplo abaixo estamos passando um JSON contendo apenas o campo chamado title, isso significa que todos os documentos que tiverem o title igual ao que estamos passando no JSON serão retornando na nossa consulta.

// Input
db.posts.find({title: "Introdução a PWA"});
// Output
{
    "_id" : ObjectId("601ed2614fb18f6b8e31fd46"),
    "title" : "Introdução a PWA",
    "content" : "...",
    "categories" : [  "front-end", "pwa" ],
    "author" : { "name" : "Marcelo Michels", "about" : "..." },
    "likes" : 0
}

Definindo quais campos do documento queremos que sejam retornados

Na função find podemos passar no primeiro parâmetro um JSON para a consulta que desejamos, assim como também podemos passar no segundo parâmetro quais campos dos documentos queremos que sejam retornados para utilizarmos.
No exemplo abaixo vamos passar no primeiro parâmetro {}, isso vai retornar todos os posts, no segundo parâmetro vamos passar o JSON { title: 1} o que sinaliza que queremos que seja retornado apenas o campo title de cada documento, porem o campo _id sempre vai ser retornado, a não ser que indiquemos que não o queremos da seguinte forma { _id: 0, title: 1}, ou seja, nesse segundo JSON passamos 0 para os campos que não queremos e 1 para os campos que queremos.

// Input
db.posts.find({}, { _id: 0, title: 1 });
// Output
[
  { title: "Introdução a banco de dados NoSQL" },
  { title: "Introdução a Rust" },
  { title: "Fazendo backup automatizado do MongoDB" },
  { title: "Performance para páginas WEB" },
  { title: "Introdução a PWA" },
];

Busca com paginação

Em casos onde temos muitos documentos, buscar esses documentos em quantidades menores pode ser uma boa opção, para isso podemos acrescentar ao find as funções skip e limit onde define quantos registros ignorar e quantos registros retornar, respectivamente.

// Input
db.posts.find({}, { _id: 0, title: 1 }).skip(1).limit(3);
// Output
[
  { title: "Introdução a Rust" },
  { title: "Fazendo backup automatizado do MongoDB" },
  { title: "Performance para páginas WEB" },
];

Buscando documentos com expressões regulares

No JSON que passamos para a função find também podemos passar expressões regulares, ampliando nossas possibilidades de buscas, permitindo por exemplo, buscar todos os usuários que tenham um e-mail valido, entre outros tipos de validações, no exemplo atual vamos buscar por todos os posts que contenham no titulo do post a palavra Introdução e vamos querer apenas o title de cada post.

// Input
db.posts.find({ title: /Introdução/ }, { _id: 0, title: 1 });
// Output
[
  { title: "Introdução a banco de dados NoSQL" },
  { title: "Introdução a Rust" },
  { title: "Introdução a PWA" },
];

Buscando documentos a partir de informações de sub documentos

Nosso documento de posts contem dentro dele um sub documento que contem os dados do autor, caso queiramos buscar todos os documentos de posts filtrando pelos dados do sub documento author também é possível e muito fácil.

// Input
db.posts.find(
  { "author.name": "Joaquim Augusto Michels" },
  { _id: 0, title: 1 }
);
// Output
[{ title: "Introdução a PWA" }];

Buscando documentos a partir de informações de sub listas

Vamos buscar um documento a partir de uma informação que está dentro de uma sub lista no nosso documento, que no caso é a lista de categorias que ficam dentro do campo categories.

// Input
db.posts.find({ categories: "database" }, { _id: 0, title: 1 });
// Output
[
  { title: "Introdução a banco de dados NoSQL" },
  { title: "Fazendo backup automatizado do MongoDB" },
];

Buscando documentos utilizando operador $in

Mongo nos ofere alguns operadores para agregamos mais poderes em nossas buscas, um deles é o $in, podemos encontrar mais alguns na documentação em https://docs.mongodb.com/manual/reference/operator/.

// Input
db.posts.find(
  { categories: { $in: ["infra", "performance"] } },
  { _id: 0, title: 1 }
);
// Output
[
  { title: "Fazendo backup automatizado do MongoDB" },
  { title: "Performance para páginas WEB" },
];

Atualizando documentos

Já aprendemos inserir e buscar dados em uma coleção do MongoDB, agora vamos atualizar alguns desses documentos para depois realizarmos umas consultas mais avançadas.

Substituindo um documento inteiro

Utilizaremos a função updateOne qual no primeiro parâmetro espera um JSON para localizar o
Quando queremos substituir todas as informações do documento por um novo documento passamos no segundo parâmetro um operador $replaceWith que é onde vai ser passado o novo documento a

// Input
db.posts.updateOne(
  { title: "Performance para páginas WEB" },
  [
    {
      "$replaceWith": {
        title: "Performance em páginas WEB",
        content: "...",
        categories: ["performance", "front-end"],
        author: { name: "Marcelo Michels", about: "..." },
        likes: 0,
      },
    },
  ]
);
// Output
{
    "matchedCount" : 1,
    "modifiedCount" : 1
}

Atualizando parte de um documento

Para atualizar parte de um documento utilizaremos o operador $set no lugar de $replaceWith, dessa forma o JSON que passarmos dentro desse operador será adicionado ao documento sem modificar as demais informações do documento (como se fosse um merge entre o documento que já está salvo e o JSON que estamos enviando no $set).
Dessa forma vamos atualizar a quantidade de likes de um post para 1.

// Input
db.posts.updateOne(
  { title: "Introdução a banco de dados NoSQL" },
  [
    {
      "$set": {
        likes: 1,
      },
    },
  ]
);
// Output
{
    "matchedCount" : 1,
    "modifiedCount" : 1
}

Atualizando muitos documentos

Caso queira atualizar muitos documentos utilizaremos a função updateMany, onde pode atualizar mais que um documento na mesma operação, assim todos os documentos que se aplicarem na query no primeiro parâmetro serão atualizados. Da mesma forma que buscamos todos os documentos passando um JSON vazio, para atualizar todos os documentos passamos um JSON vazio também na query do nosso updateMany.

// Input
db.posts.updateMany(
  { },
  [
    {
      "$set": {
        published: true,
      },
    },
  ]
);
// Output
{
    "matchedCount" : 5,
    "modifiedCount" : 5
}

Com a operação acima todos os nossos posts receberam o campo published com valor true.

Atualizando campo de um documento de forma incremental

Seguindo o comando anterior $set, cada vez que um post receber um like teríamos que buscar o post para saber quantos likes ele tinha para adicionar mais 1 nesse valor e salvar a informação novamente, mas com o operador $inc podemos apenas incrementar o valor que já temos salvo com o valor que queremos incrementar.

// Input
db.posts.updateOne(
  { title: "Introdução a banco de dados NoSQL" },
  {
    "$inc": {
      likes: 1,
    },
  }
);
// Output
{
    "matchedCount" : 1,
    "modifiedCount" : 1
}

Atualizando sub lista de documento com novos registros

Vamos imaginar os comentários de um post, caso queiramos gravar eles dentro de uma sub lista do nosso documento vamos precisar utilizar o operador $push

// Input
db.posts.updateOne(
  { title: "Introdução a banco de dados NoSQL" },
  {
    "$push": {
      "comments": {
        "$each": [{
          "name" : "Marcelo"
          "message": "Muito legal, parabéns"
        }]
      }
    }
  }
);
// Output
{
    "matchedCount" : 1,
    "modifiedCount" : 1
}

Deletando documentos

Com base no conhecimento nas operações que já temos deletar um documento não se torna muito diferente do que já aprendemos, então segue abaixo um exemplo com a utilização da função remove, usando também um operador novo $lte (qual também pode ser usado no find) que retorna todos os documentos que tenham um determinado campo com valor menor do que estamos passando na query.
Com o remove abaixo estamos removendo todos posts que o campo likes seja menor ou igual a 1.

// Input
db.posts.remove({ "likes": { "$lte": 1 } });
// Output
Removed 4 record(s)

Consulte também outros operador de maior e menor https://docs.mongodb.com/manual/reference/operator/query-comparison/

Conclusão

Se você executou todos os comandos que aprendemos aqui, na nossa coleção de posts deve ter sobrado apenas um único documento igualmente o que consta abaixo.

{
    "_id" : ObjectId("601ed2504fb18f6b8e31fd42"),
    "title" : "Introdução a banco de dados NoSQL",
    "content" : "...",
    "categories" : [
        "database",
        "nosql",
        "mongodb"
    ],
    "author" : {
        "name" : "Marcelo Michels",
        "about" : "..."
    },
    "likes" : 2,
    "published" : true,
    "comments" : [
        {
            "name" : "Marcelo",
            "message" : "Muito legal, parabéns"
        }
    ]
}

Espero utilizar desses exemplos no futuro e espero que possa ser útil para alguém também.