Forem: Vitor Vargas

Implementing symmetric and asymmetric encryption with NodeJS

Vitor Vargas — Wed, 15 May 2024 15:48:55 +0000

In a digital world, where data is transmitted everywhere, concerns about where this data ends up are growing fast. Many companies offer services without encryption, leaving sensitive data exposed to unnecessary risks. Every year, we witness personal data leaks, and that is why at SuperViz, we have done work to guarantee the security and privacy of our users' data.

After much study and being responsible for implementing it internally in the company, I would like to share this article to help reduce such incidents. At the end of the article, you will be able to create encryptions using symmetric keys and using asymmetric keys.

Asymmetric and Symmetric Keys

Before diving into encryption, it's extremely valuable to know the difference between asymmetric and symmetric keys.

Symmetric Encryption:
- Uses a single key for both encrypting and decrypting data.
- The same key is shared between the sender and the receiver of the message.
- It is faster and more efficient in terms of processing than asymmetric encryption.
Asymmetric Encryption (or public key encryption):
- Uses a pair of keys: a public key and a private key;
- The public key is used to encrypt the data, while the private key is used to decrypt the data;
- Each recipient has their own private key and a public key, with only the public key being shared with other interested parties;
- It is more secure than symmetric encryption due to the separation of public and private keys;
- It is slower and requires more computational resources than symmetric encryption.

In summary, the main difference between symmetric and asymmetric encryption lies in how the keys are generated and used to encrypt and decrypt data, as well as in the relative efficiency and security of each approach.

Encrypting with Symmetric Keys

In this article we will use the AES-256-CBC encryption, with CBC being the acronym for Cipher Block Chaining.

CBC is a way of encrypting information. Imagine you have a message that you want to keep secure, with CBC it works like this:

Divide the message into small pieces, called blocks;
Instead of simply encrypting each block separately, as is the case in some methods, in CBC each block is mixed with the previous block before being encrypted. It's as if each block depended on what came before it;
This creates a kind of "chain" of blocks, where each block is linked to the previous one;
This link between the blocks makes it more difficult for someone who does not have the correct key to decipher the message. Even if someone tries to tamper with one block, it will affect all subsequent blocks, making decipherment much more difficult.

Knowing how CBC works, let's create our first message encrypted with AES-256-CBC! Imagine that we are going to create a function called encrypt, it will be responsible for creating the symmetric key and performing the encryption, it will have the following parameters: salt, passphrase, text.

The passphrase will be required to use in encryption to decrypt the content. Additionally, we will need a salt, which is a random text used as a basis for encrypting the data. This salt will increase the security of the encryption, making it more difficult for third parties to decipher protected content.

In the first line of the function, we will generate the symmetric key. This key will be the only key used to both encrypt and decrypt the content. It will be shared between the sender and the recipient.

import * as crypto from 'crypto'

const salt = randomBytes(32).toString('hex');
const passphrase = 'password';

const encrypt = (passphrase, salt, text) => {
  const key = scryptSync(passphrase, salt, 32)
  ...
}

In line 7, we create our symmetric key. In the next line, we will need to generate the Initialization Vector. The Initialization Vector (IV) is like a secret ingredient in encryption, it is a random value that joins with the key to scramble the data, which makes encryption more secure and difficult to break.

const iv = crypto.randomBytes(16)

Now let's encrypt the message using our key and iv.

We will create our cipher passing 3 parameters: the algorithm, the key and the iv;
We add the text to the cipher and change the text format from utf-8 to hex;
We obtain the final encrypted content.

const cipher = crypto.createCipheriv('aes-256-cbc', key, iv)
let encrypted = cipher.update(text, 'utf8', 'hex')

encrypted += cipher.final('hex')

We are approaching the end, but a challenge arises. To decrypt the message content, we need the IV (Initialization Vector), however, it is crucial that each IV is unique and random. Storing the IV alongside the encrypted message would compromise security. A commonly adopted solution is to merge the IV with the encrypted message in strategic locations, keeping its position confidential.

const part1 = encrypted.slice(0, 17)
const part2 = encrypted.slice(17)

return `${part1}${iv.toString('hex')}${part2}`

It is important to point out that, in parts 1 and 2, our encrypted text contains only 32 characters.

And in the end, our encryption function looked like this:

import * as crypto from 'crypto'

const salt = crypto.randomBytes(32).toString('hex');
const passphrase = 'password';

const encrypt = (passphrase, salt, text) => {
  const key = crypto.scryptSync(passphrase, salt, 32)
  const iv = crypto.randomBytes(16)

  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv)
  let encrypted = cipher.update(text, 'utf8', 'hex')

  encrypted += cipher.final('hex')

  const part1 = encrypted.slice(0, 17)
  const part2 = encrypted.slice(17)

  return `${part1}${iv.toString('hex')}${part2}`
}

Decrypting with Symmetric Keys

Now that we have our content encrypted at some point, we will need to decrypt the content. Some steps will be like what we did when encrypting the content. First let's recover our key.

import * as crypto from 'crypto'

const salt = crypto.randomBytes(32).toString('hex');
const passphrase = 'password';

const decrypt = (passphrase, salt, text) => {
  const key = crypto.scryptSync(passphrase, salt, 32)
  ...
}

Next, to define the positions that we place when encrypting our content, which in the case of this article we are using position 17:

const ivPosition = {
  start: 17,
  end: 17 + 32
}

const iv = Buffer.from(text.slice(ivPosition.start, ivPosition.end), 'hex')

Having the IV in hand, just get the encrypted content:

const part1: string = text.slice(0, ivPosition.start)
const part2: string = text.slice(ivPosition.end)

const encryptedText = `${part1}${part2}`

Now we have both the encrypted content and the IV, we can then begin the process of deciphering the content. The process is similar to encryption:

We will create our decryptor passing three parameters: the algorithm, the key and the iv;
we add the cipher text and change the text format from hex to utf-8;
We obtain the final deciphered content.

const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv)
let decrypted = decipher.update(encryptedText, 'hex', 'utf8')
decrypted += decipher.final('utf8')

return decrypted

In the end, we have a code similar to this:

import * as crypto from 'crypto'

const salt = crypto.randomBytes(32).toString('hex');
const passphrase = 'password';

const decrypt = (passphrase, salt, text) => {
  const key = crypto.scryptSync(passphrase, salt, 32)
  const ivPosition = {
    start: 17,
    end: 17 + 32
  }

  const iv = Buffer.from(text.slice(ivPosition.start, ivPosition.end), 'hex')
  const part1: string = text.slice(0, ivPosition.start)
  const part2: string = text.slice(ivPosition.end)

  const encryptedText = `${part1}${part2}`

  const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv)
  let decrypted = decipher.update(encryptedText, 'hex', 'utf8')
  decrypted += decipher.final('utf8')

  return decrypted
}

Creating Asymmetric Keys

Asymmetric keys, or public key cryptography, have transformed the way we protect sensitive information online. This guarantees extra security, although it is slower and requires more resources.

NodeJS supports a variety of asymmetric key types to meet diverse encryption needs. These include:

RSA: A widely used algorithm for asymmetric encryption, known for its security and efficiency;
DSA: Digital Signature Algorithm, often used for digital signatures and authentication;
EC (Elliptic Curve): Elliptic curve encryption algorithm, which offers a high level of security with smaller keys compared to RSA;
ed25519: A high-performance digital signature system based on elliptic curves;
ed448: Similar to ed25519, but with a higher level of security due to the larger key size;
x25519 and x448: Key exchange protocols based on elliptic curves, offering security and efficiency in restricted environments.

This variety of options allows developers to choose the algorithm best suited to their specific needs, balancing security, performance, and efficiency.

For this article, we will use the implementation of the RSA algorithm, given its wide use. In the initial stage, it is crucial to generate the asymmetric keys: the Public Key and the Private Key. To do this, it is essential to specify the types and formats of these keys. We will opt for the PEM (Privacy-Enhanced Mail) format for both keys, thus ensuring a consistent and secure approach.

generateKeyPair(passphrase: string): KeyPair {
  const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
    modulusLength: 4096,
    publicKeyEncoding: {
      type: 'spki',
      format: 'pem'
    },
    privateKeyEncoding: {
      type: 'pkcs8',
      format: 'pem',
      cipher: 'aes-256-cbc',
            passphrase: passphrase 
    }
  })

  return {
    publicKey,
    privateKey
  }
}

Firstly, it is important to understand the generateKeyPairSync function. It is responsible for generating a pair of keys: one public and one private.

When generating these keys, some parameters are essential:

modulusLength: This parameter defines the length of the module. In the case of RSA, the minimum length is 4096;
publicKeyEncoding: This object establishes the type and format of the public key. The type is defined as spki (Subject Public Key Info), a standard format for public keys. The format is pem, which is a base64 encoding type;
privateKeyEncoding: This object defines the type, format, cipher, and passphrase of the private key. The type is defined as pkcs8, also a standard format for private keys. The format is pem, similar to the public key. The cipher is defined as aes-256-cbc, an encryption algorithm as we saw earlier. The secret phrase, our passphrase, is the password used to encrypt the private key.

In NodeJS, there are two types of public key (pkcs1 and spki) and two types of private key (pkcs1 and pkcs8) when using RSA.

Here, we chose the spki/pkcs8 format. To add an extra layer of security, we also use the AES-256-CBC (Cipher Block Chaining) algorithm as mentioned previously.

As a result, the generateKeyPairSync function returns an object containing the generated public and private keys.

Differences between PKCS1 and PKCS8

PKCS is the acronym for "Public Key Cryptography Standards", which are a set of standards developed to assist the implementation of public key cryptography. Among these standards, we have PKCS1 and PKCS8, which describe formats for encoding private keys.

PKCS1 is the first PKCS standard, used specifically for encoding RSA keys. It details the process of encoding an RSA private key, which is relatively simple as an RSA key only requires a few integers.

In contrast, PKCS8 is a more comprehensive standard used to encode any type of private key. It can be used not only for RSA keys but also for other types of keys such as DSA or EC (Elliptic Curve). Thus, PKCS8 is a more general format compared to PKCS1 as it includes information about the key type in the private key data structure.

In short, the difference between PKCS1 and PKCS8 is that PKCS1 is specific to RSA keys, while PKCS8 can be used to encode any type of private key.

Encrypting with Asymmetric Keys

With our Public Key at your disposal, it is very easy to encrypt any message.

First, we create a function that requires two parameters: text and publicKey;
Next, we use the publicEncrypt function, which will be used to encrypt the text;
After that, we use Buffer.from(text, 'utf8') to convert the text into a UTF-8 encoded buffer;
Finally, we use toString('base64') to convert the buffer to base64.

const encrypt = (text, publicKey) => {
  return publicEncrypt(publicKey, Buffer.from(text, 'utf8')).toString('base64');
}

With this, we have our encrypted message ready to be stored in a database or something similar.

Decrypting with asymmetric keys

To decrypt content, we only need our Private Key and the passphrase specified when creating the asymmetric keys.

First, we create a function that requires two parameters: text and PrivateKey;
Next, we use the privateDecrypt function, which will be used to decrypt the text;
We pass the PrivateKey and Passphrase to the function;
After that, we use Buffer.from(text, 'base64') to convert the text to a base64 buffer;
Lastly we use .toString('utf8') to convert all content to utf8

const decrypt = (encryptedText, privateKey) => {
  return privateDecrypt({
    key: privateKey,
    passphrase
  }, Buffer.from(encryptedText, 'base64')).toString('utf8');
}

After these steps, we have our original message back. With this, we complete the full cycle of encryption and decryption using asymmetric keys.

In conclusion, encryption plays a crucial role in protecting sensitive data and information in today's digital era.

I hope that, through this article, you have gained a deeper understanding of the differences and applications between symmetric and asymmetric encryption. Furthermore, with the code examples provided, you should be able to implement your own encryption and decryption functions in NodeJS.

Remember, data security is an important responsibility and encryption is one of the most effective tools we can use to ensure that security.

Como instalar o driver da NVIDIA no Arch Linux

Vitor Vargas — Tue, 14 Nov 2023 13:00:00 +0000

Por vezes, a documentação do Arch Linux pode parecer um labirinto, repleto de informações abrangentes, mas tão extenso que é fácil se perder. Este artigo tem como objetivo simplificar o processo de configuração do driver da NVIDIA no Arch Linux, proporcionando um guia mais acessível para mim e para outros que possam enfrentar desafios semelhantes no futuro.

Verificação da Arquitetura do GPU NVIDIA

Antes de prosseguir, é crucial verificar a arquitetura exata da GPU NVIDIA instalada no seu sistema. Isso garantirá a compatibilidade correta com o driver adequado. Execute o seguinte comando para identificar a arquitetura da sua GPU:

`lspci | grep -E "VGA|3D"`

Certifique-se de pesquisar as informações da GPU NVIDIA no site oficial da NVIDIA para garantir a seleção correta do driver.

Passo 1: Atualização do Sistema
Certifique-se de que seu sistema está atualizado com o seguinte comando:

sudo pacman -Syu --noconfirm

Passo 2: Instalação dos Pacotes Necessários
Instale os pacotes necessários para o driver da NVIDIA com o comando:

sudo pacman -S --noconfirm nvidia nvidia-utils nvidia-settings opencl-nvidia xorg-server-devel

Dica: caso estiver usando kernel LTS, instale nvidia-lts ao invés de nvidia.

Passo 3: Configuração do Xorg
Crie o diretório necessário e configure o arquivo para o Xorg:

mkdir -p /etc/X11/xorg.conf.d

cat >> /etc/X11/xorg.conf.d/10-nvidia-drm-outputclass.conf<<EOF
Section "OutputClass"
    Identifier "intel"
    MatchDriver "i915"
    Driver "modesetting"
EndSection

Section "OutputClass"
    Identifier "nvidia"
    MatchDriver "nvidia-drm"
    Driver "nvidia"
    Option "AllowEmptyInitialConfiguration"
    Option "PrimaryGPU" "yes"
    ModulePath "/usr/lib/nvidia/xorg"
    ModulePath "/usr/lib/xorg/modules"
EndSection
EOF

Neste passo, estamos criando e configurando o arquivo 10-nvidia-drm-outputclass.conf no diretório /etc/X11/xorg.conf.d/. Este arquivo é essencial para definir as configurações de saída do Xorg para as GPUs Intel e NVIDIA. Ele usa as seções "OutputClass" para associar o driver modesetting à GPU Intel e o driver nvidia à GPU NVIDIA.

Passo 4: Configuração do GDM (GNOME Display Manager)

mkdir -p /usr/share/gdm/greeter/autostart
mkdir -p /etc/xdg/autostart

cat >> /usr/share/gdm/greeter/autostart/optimus.desktop<<EOF
[Desktop Entry]
Type=Application
Name=Optimus
Exec=sh -c "xrandr --setprovideroutputsource modesetting NVIDIA-0; xrandr --auto"
NoDisplay=true
X-GNOME-Autostart-Phase=DisplayServer
EOF

cat >> /etc/xdg/autostart/optimus.desktop<<EOF
[Desktop Entry]
Type=Application
Name=Optimus
Exec=sh -c "xrandr --setprovideroutputsource modesetting NVIDIA-0; xrandr --auto"
NoDisplay=true
X-GNOME-Autostart-Phase=DisplayServer
EOF

Aqui, estamos criando dois arquivos .desktop para integrar a otimização do Optimus ao GDM. O GDM é configurado para executar automaticamente o script xrandr para alocar as saídas de vídeo corretamente entre as GPUs Intel e NVIDIA durante a inicialização do servidor gráfico.

O que é NVIDIA Optimus?
NVIDIA Optimus é uma tecnologia que gerencia automaticamente o uso da placa de vídeo integrada e dedicada em laptops para otimizar o desempenho e economizar energia. Em resumo, ajuda a equilibrar o poder de processamento conforme necessário.

Caso esteja usando um Gerenciador de Login diferente do GDM siga a documentação do ArchLinux aqui.

Passo 5: Configuração do Modprobe
Configure o Modprobe para o driver da NVIDIA:

mkdir -p /etc/modprobe.d

cat >> /etc/modprobe.d/nvidia-drm-nomodeset.conf<<EOF
options nvidia-drm modeset=1
EOF

Este passo configura o Modprobe para o driver da NVIDIA, especificamente para o nvidia-drm. Estamos adicionando uma opção ao arquivo nvidia-drm-nomodeset.conf para habilitar o modo modeset, que é essencial para uma integração suave do driver NVIDIA com o ambiente gráfico.

Passo 6: Reconstrução do Initramfs
Reconstrua o Initramfs para garantir que as alterações sejam aplicadas:

sudo mkinitcpio -P

A reconstrução do Initramfs é crucial para aplicar as alterações feitas nos módulos do kernel, garantindo que o sistema reconheça corretamente o novo ambiente gráfico com o driver NVIDIA.

Passo 7: Execução de nvidia-xconfig

sudo nvidia-xconfig

O comando nvidia-xconfig é utilizado para gerar um arquivo de configuração Xorg específico para o driver da NVIDIA. Isso ajuda a garantir que as configurações necessárias estejam presentes e otimizadas para a GPU NVIDIA instalada.

Passo 8: Teste e Verificação do Driver NVIDIA

Reinicie o sistema para aplicar todas as configurações. Após a reinicialização, verifique se o driver NVIDIA está carregado corretamente usando o comando: nvidia-smi
Além disso, abra o NVIDIA X Server Settings ou utilize o comando nvidia-settings para acessar a interface gráfica e verificar as configurações específicas da GPU.

Com a conclusão da configuração do driver NVIDIA no Arch Linux, espero sinceramente que este guia tenha sido valioso para você! Agradeço sinceramente por investir seu tempo na leitura deste artigo.

Fontes

How to install the NVIDIA driver on Arch Linux.

Vitor Vargas — Mon, 13 Nov 2023 13:00:00 +0000

Sometimes, the Arch Linux documentation may feel like a maze, filled with comprehensive information but so extensive that it's easy to get lost. This article aims to simplify the process of configuring the NVIDIA driver on Arch Linux, providing a more accessible guide for myself and others who may face similar challenges in the future.

Checking the NVIDIA GPU Architecture

Before proceeding, it is crucial to check the exact architecture of the NVIDIA GPU installed on your system. This will ensure correct compatibility with the appropriate driver. Run the following command to identify your GPU's architecture:

lspci | grep -E "VGA|3D"

Make sure to look up the NVIDIA GPU information on the official NVIDIA website to ensure the correct driver selection.

Step 1: System Update
Make sure your system is up to date with the following command:

sudo pacman -Syu --noconfirm

Step 2: Installation of Required Packages
Install the necessary packages for the NVIDIA driver with the command:

sudo pacman -S --noconfirm nvidia nvidia-utils nvidia-settings opencl-nvidia xorg-server-devel

Tip: If you are using the LTS kernel, install nvidia-lts instead of nvidia.

Step 3: Xorg Configuration
Create the necessary directory and configure the file for Xorg:

mkdir -p /etc/X11/xorg.conf.d

cat >> /etc/X11/xorg.conf.d/10-nvidia-drm-outputclass.conf<<EOF
Section "OutputClass"
    Identifier "intel"
    MatchDriver "i915"
    Driver "modesetting"
EndSection

Section "OutputClass"
    Identifier "nvidia"
    MatchDriver "nvidia-drm"
    Driver "nvidia"
    Option "AllowEmptyInitialConfiguration"
    Option "PrimaryGPU" "yes"
    ModulePath "/usr/lib/nvidia/xorg"
    ModulePath "/usr/lib/xorg/modules"
EndSection
EOF

In this step, we are creating and configuring the 10-nvidia-drm-outputclass.conf file in the /etc/X11/xorg.conf.d/ directory. This file is essential for defining Xorg output settings for Intel and NVIDIA GPUs. It uses the "OutputClass" sections to associate the modesetting driver with the Intel GPU and the nvidia driver with the NVIDIA GPU.

Step 4: GDM (GNOME Display Manager) Configuration

mkdir -p /usr/share/gdm/greeter/autostart
mkdir -p /etc/xdg/autostart

cat >> /usr/share/gdm/greeter/autostart/optimus.desktop<<EOF
[Desktop Entry]
Type=Application
Name=Optimus
Exec=sh -c "xrandr --setprovideroutputsource modesetting NVIDIA-0; xrandr --auto"
NoDisplay=true
X-GNOME-Autostart-Phase=DisplayServer
EOF

cat >> /etc/xdg/autostart/optimus.desktop<<EOF
[Desktop Entry]
Type=Application
Name=Optimus
Exec=sh -c "xrandr --setprovideroutputsource modesetting NVIDIA-0; xrandr --auto"
NoDisplay=true
X-GNOME-Autostart-Phase=DisplayServer
EOF

Here, we are creating two .desktop files to integrate Optimus optimization with GDM. GDM is configured to automatically run the xrandr script to allocate video outputs correctly between Intel and NVIDIA GPUs during the graphical server startup.

What is NVIDIA Optimus?
NVIDIA Optimus is a technology that automatically manages the use of integrated and dedicated graphics cards in laptops to optimize performance and save energy. In summary, it helps balance processing power as needed.

If you are using a different Login Manager than GDM, follow the ArchLinux documentation here.

Step 5: Modprobe Configuration
Configure Modprobe for the NVIDIA driver:

mkdir -p /etc/modprobe.d

cat >> /etc/modprobe.d/nvidia-drm-nomodeset.conf<<EOF
options nvidia-drm modeset=1
EOF

This step configures Modprobe for the NVIDIA driver, specifically for nvidia-drm. We are adding an option to the nvidia-drm-nomodeset.conf file to enable the modeset mode, which is essential for smooth integration of the NVIDIA driver with the graphical environment.

Step 6: Initramfs Reconstruction
Rebuild Initramfs to ensure the changes are applied:

sudo mkinitcpio -P

Initramfs reconstruction is crucial to apply changes made to kernel modules, ensuring the system correctly recognizes the new graphical environment with the NVIDIA driver.

Step 7: Running nvidia-xconfig

sudo nvidia-xconfig

The nvidia-xconfig command is used to generate a specific Xorg configuration file for the NVIDIA driver. This helps ensure that the necessary settings are present and optimized for the installed NVIDIA GPU.

Step 8: Testing and Verifying the NVIDIA Driver

Restart the system to apply all configurations. After the restart, check if the NVIDIA driver is loaded correctly using the command: nvidia-smi. Additionally, open the NVIDIA X Server Settings or use the nvidia-settings command to access the graphical interface and check specific GPU settings.

With the completion of the NVIDIA driver configuration on Arch Linux, I sincerely hope this guide has been valuable to you! Thank you sincerely for investing your time in reading this article.

Sources

Como usar hot reload em Go

Vitor Vargas — Sun, 12 Nov 2023 11:00:00 +0000

Quando dei os primeiros passos no estudo de Golang, optei por usar o Chi para gerenciar as rotas da minha primeira API. Contudo, me deparei com a ausência de um recurso essencial: o hot reload. Em busca de aprimorar meu processo de desenvolvimento, cai de cabeça em pesquisas na internet. Infelizmente, não encontrei soluções simples, mas achei algumas alternativas como executar o Go em um nodemon, o que me causou certo desconforto. Afinal, por que misturar Go com Node?

Foi então que me deparei com o taskfile.dev. O Task é uma ferramenta de automação projetada para ser mais acessível do que outras opções, como o GNU Make.

Sendo desenvolvido em Go, o Task é um binário simples, sem nenhuma outra dependência. Isso significa que você não enfrentará complicações durante o processo de instalação, tornando a utilização desta ferramenta de automação uma experiência descomplicada.

Para começar, é crucial realizar a instalação do taskfile. Siga as instruções do manual de instalação disponível em https://taskfile.dev/installation/.

Após a instalação, precisamos criar um arquivo para configurar o taskfile em seu projeto. Portanto, no diretório raiz do seu projeto crie o arquivo taskfile.yml com o seguinte conteúdo:

version: '3'

tasks:
  :build:
    cmds:
      - 'go build -o dist/main ./main.go'
    sources:
      - ./*.go,
      - ./**/*.go

  :start:
    cmds:
      - task: :build
      - './dist/main'
    sources: 
      - ./*.go,
      - ./**/*.go

O arquivo taskfile.yml contém instruções para a ferramenta de automação task (ou go-task) sobre como executar diferentes tarefas relacionadas ao desenvolvimento do projeto em Go. Vamos analisar o conteúdo do arquivo:

version: '3'

tasks:
  :build:
    cmds:
      - 'go build -o dist/main -mod=vendor ./cmd/main.go'
    sources:
      - ./*.go
      - ./**/*.go

  :start:
    cmds:
      - task: :build
      - './dist/main'
    sources:
      - ./*.go
      - ./**/*.go

Versão do Taskfile: A primeira linha especifica a versão do taskfile que está sendo usada.
Definição de Tarefas:
- :build: Esta tarefa compila o projeto Go. Ela usa o comando go build para compilar o código-fonte localizado em ./main.go e salva o executável resultante em dist/main.
- :start: Esta tarefa depende da tarefa :build e, em seguida, executa o executável gerado (./dist/main). Isso proporciona uma maneira de compilar e iniciar o aplicativo com um único comando.
Sources:
- Ambas as tarefas têm uma lista de sources que indicam quais arquivos ou diretórios devem ser observados para acionar a execução da tarefa quando houver alterações. Isso é útil para usar o hot reload, pois permite que o task detecte mudanças nos arquivos e execute automaticamente as tarefas relacionadas.
Comando para Execução:
- Os comandos sob a chave cmds são os comandos reais executados pela tarefa. Eles são escritos como se fossem comandos de terminal padrão.

Depois de configurar esse taskfile.yml e instalar o task, você pode usar o comando go-task :start -w --interval=500ms para compilar e iniciar seu aplicativo, com a capacidade de hot reload sempre que houver alterações nos arquivos especificados. Este processo simplifica o ciclo de desenvolvimento.

Dica: se isso não funcionar, tente substituir go-task por task.

Em resumo, a integração do taskfile em projetos Go oferece uma solução elegante para a gestão de tarefas de desenvolvimento, como compilação e execução do aplicativo, especialmente quando se trata da necessidade crucial de hot reload. Ao adotar o taskfile, você obtém uma ferramenta de automação simples, baseada em Go, eliminando a necessidade de soluções mais complexas e mistas. A configuração apresentada no taskfile.yml permite compilar e iniciar o aplicativo com facilidade, enquanto o monitoramento contínuo das alterações nos arquivos facilita a atualização automática, proporcionando um fluxo de desenvolvimento mais eficiente e livre de complicações. Ao incorporar essa abordagem em seu fluxo de trabalho, você maximiza a produtividade e mantém o foco no desenvolvimento de qualidade em vez de lidar com tarefas manuais repetitivas.

How to use hot reload in Go

Vitor Vargas — Sat, 11 Nov 2023 17:06:26 +0000

When I took my first steps into studying Golang, I chose to use Chi to manage the routes of my first API. However, I faced the absence of an essential feature: hot reload. In an effort to enhance my development process, I delved into extensive research on the internet. Unfortunately, I didn't find simple solutions and encountered alternatives, such as running Go with nodemon, which made me somewhat uncomfortable. After all, why mix Go with Node?

That's when I came across taskfile.dev. Task is an automation tool designed to be more accessible than other options, such as GNU Make.

Developed in Go, Task is a simple binary with no other dependencies. This means you won't face complications during the installation process, making the use of this automation tool a straightforward experience.

To get started, it's crucial to perform the installation of taskfile. Follow the instructions in the manual available at https://taskfile.dev/installation/.

After a successful installation, we need to create a file to configure taskfile in your project. So, in the root directory of your project create the taskfile.yml file with the following content:

version: '3'

tasks:
  :build:
    cmds:
      - 'go build -o dist/main ./main.go'
    sources:
      - ./*.go,
      - ./**/*.go

  :start:
    cmds:
      - task: :build
      - './dist/main'
    sources: 
      - ./*.go,
      - ./**/*.go

Taskfile Version: The first line specifies the version of the taskfile being used.
Task Definitions:
- :build: This task compiles the Go project. It uses the go build command to compile the source code located in ./main.go and saves the resulting executable in dist/main.
- :start: This task depends on the :build task and then executes the generated executable (./dist/main). This provides a way to compile and start the application with a single command.
Sources:
- Both tasks have a list of sources indicating which files or directories should be watched to trigger task execution when changes occur. This is useful for the hot reload feature, allowing task to detect changes in source files and automatically execute related tasks.
Execution Command:
- The commands under the cmds key are the actual commands executed by the task. They are written as if they were standard terminal commands.

After configuring this taskfile.yml and installing task, you can use the command go-task :start -w --interval=500ms to compile and start your application, with the ability to hot reload whenever changes occur in the specified files. This process simplifies the development cycle.

TIP: If this doesn't work, try replacing go-task with task.

In summary, the integration of taskfile in Go projects provides an elegant solution for managing development tasks such as application compilation and execution, especially when it comes to the crucial need for hot reload. By adopting taskfile, you gain a straightforward automation tool based on Go, eliminating the need for more complex and mixed solutions. The configuration presented in taskfile.yml allows for easy compilation and startup of the application, while continuous monitoring of changes in source files facilitates automatic updates, providing a more efficient and complication-free development flow. By incorporating this approach into your workflow, you maximize productivity and maintain a focus on quality development rather than dealing with repetitive manual tasks.