Next.js vem ganhando força na comunidade de desenvolvimento Web mas pouco tem se falado sobre seu uso para desenvolvimento de API's REST. Neste artigo iremos quebrar esse "tabu" demonstrando a utilização de APIs REST com Next.js, Prisma e PostgreSQL.

Criando uma API REST com Next.js, Prisma e PostgreSQL

Introdução

Tecnologias utilizadas

Pré-requisitos

Conhecimento necessário

Ambiente de desenvolvimento

Criando o projeto Next.js

Criando uma instância do PostgreSQL

Configurando o Prisma

Entendendo o arquivo Schema Prisma

Modelo de dados

Migration do modelo

Criando o CRUD

Criando um Artigo - Create

Obtendo um ou mais Artigos - GET

Alterando um Artigo - PUT

Deletando um Artigo - DELETE

Conclusão

Aprenda como converter rapidamente o complicado e extenso ABI gerado pelo compilador do Solidity em um ABI de simples compreensão humana, sem abrir mão de suas funcionalidades utilizando o Hardhat o Ethers.js.

Guia prático para converter JSON ABI do Solidity em uma ABI de fácil compreensão utilizando o Hardhat.

Criando o projeto

Implementação de um contrato ERC-20 com OpenZeppelin

Compilando o Contrato e analisando a ABI

Tornando a ABI mais simples e legível

Explicando o código


Faala Devs!! Iremos juntos também aprender um pouco mais sobre o Hardhat, pois neste artigo vamos compilar e testar nosso contrato de "Hello World".

Você encontra o código fonte do projeto neste [respositório](https://github.com/dukes-code/beginners-guide-to-solidity) sob a branch `#beginners-guide-part-iii`.

### Estrutura do Contrato Inteligente

Um contrato, no conceito do Solidity, é um conjunto de códigos (functions) e dados (state), que residem em um específico endereço na rede blockchain Ethereum.

![basic-structure-smart-contract](/img/a-complete-beginners-guide-to-solidity-part-iii/basic-structure-smart-contract.avif 'Estrutura básica de um contrato inteligente')

_fig. 1 - estrutura básica de um contrato inteligente_

A estrutura de um contrato é muito semelhante a uma classe de outra linguagem orientada a objetos como vemos a seguir, fazendo disso um motivo que torna o aprendizado de Solidity mais simples. O arquivo de código fonte do Solidity pode conter qualquer número de definições de contrato, diretivas de importação de biblioteca e diretivas de pragma.

Cada contrato pode conter declarações de Variáveis de Estado, Funções, Modificadores de Função, Eventos, Tipos de Estrutura and Tipos de Enum. Além disso, contratos podem herdar de outros contratos.

### Contrato de armazenamento

Vamos iniciar por um exemplo simples. Neste contrato estamos armazenando uma informação na Blockchain do tipo uint (falaremos mais no futuro) e resgatamos o seu conteúdo. Sem problemas se você não entender tudo neste momento, iremos entrar em mais detalhes depois.

```solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.8.1;

import "hardhat/console.sol";

contract SimpleStorage {
    uint storedData;

    function set(uint x) public {
        storedData = x;
    }

    function get() public view returns (uint) {
        return storedData;
    }
}
```

#### License

A primeira linha informa sob qual licença de uso esta registrada o contrato, neste caso a GPL-3.0.

> **_DICA_:** A declaração da licença não é obrigatório mas é uma boa prática.

#### Pragma

Na linha seguinte estamos simplesmente dizendo que o código fonte foi escrito para a versão 0.4.16 do Solidity ou mais recente e não quebra sua funcionalidade (até, mas não incluindo a versão 0.8.1). Isso é para garantir que o contrato não se comporte de forma diferente com uma nova versão do compilador. A palavra chave pragma é chamada desta maneira, porque, no geral pragmas são instruções para o compilador sobre como tratar o código fonte.

#### Imports

Muitas vezes temos a necessidade de utilizar funções que estão em outros contratos ou mesmo fazer uso de bibliotecas externas, para atender a esta necessidade podemos realizar a importação por meio da cláusula import como visto abaixo.

#### Assinatura do Contrato

Em contract SimpleStorage efetivamente declaramos o inicio de um novo contrato atribuindo a ele o nome de SimpleStorage. Contratos assim como em linguagens de orientação a objetos podem estender outros contratos ou implementar interfaces. Assunto esse que não será abordado em nosso guia por hora.

#### Variáveis de Estado

Os tipos de dados em solidity são explícitos, ou seja nós precisamos definir através de uma palavra chave qual é o tipo da variável.

```solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

contract SimpleStorage {
    uint storedData; //variável de estado
```

A linha `uint storedData` declara uma variável de estado chamada **"storedData"** do tipo **uint** (integer não assinado de 256 bits). Você pode pensar nisso como uma única coluna de um registro em um banco de dados que pode ser consultado e alterado chamando funções do código que gerenciam o banco de dados. No caso do Ethereum, ele é sempre o contrato proprietário. E neste caso, as funções set e get podem ser usadas para modificar ou recuperar o valor da variável.

Em resumo as variáveis de estado são valores armazenados permanentemente na memória de contrato.

Para acessar uma variável de estado, você não precisa do prefixo `this.`, como é comum em outras linguagens.

#### Funções

As funções são unidades executáveis de código dentro de um contrato. Elas tratam de encapsular trechos de código para serem executados sempre que necessário.

```solidity
function soma(uint a, uint b) external pure returns(uint) {
   return a + b;
}
```

No exemplo acima temos a função **"soma"** que recebe 2 parâmetros `uint a, uint b` e retorna um `uint`.

Mais para frente iremos abordar os outros itens que compõem uma função como visibilidade, acessibilidade e modificadores.

### Hello World Solidity

Vamos colocar a mão na massa finalmente!!! Neste momento replicar o famoso "Hello World"em Solidity.

Se você está seguindo esta séria desde o início, neste momento já possuí o projeto beginners-guide-to-solidity. Caso não recomendo que volte acessa a [Parte II](/a-complete-beginners-guide-to-solidity-part-ii) e siga as instruções para criar o projeto.

Certo, para darmos início acesse a pasta raiz do projeto e crie um diretório chamado contracts e dentro dele o arquivo HelloWorld.sol conforme a seguir.

```bash
$ cd beginners-guide-to-solidity
$ mkdir contracts && cd contracts
$ touch HelloWorld.sol
```

Vamos criar o contrato HelloWorld definindo o License, Pragma e os Imports necessários.

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;

import "hardhat/console.sol";

contract HelloWorld {

}
```

Agora criemos a função **"sayHello"**, ela não deve receber nenhum parâmetro mas deve retornar uma `string`. Já que não iremos nem escrever qualquer informação na Blockchain a função deve possuir o modificador de acesso `View` e como iremos acessar ela de fora do contrato o modificador de visibilidade `External`. Veja como fica nossa função a seguir.

```solidity
function sayHello() external view returns(string memory) {
   console.log("Function sayHello foi invocada.");
   return "Hello World Solidity";
}
```

Sendo esta a versão final do nosso contrato HelloWorld, muito simples né!?

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;

import "hardhat/console.sol";

contract HelloWorld {

   function sayHello() external view returns(string memory) {
      console.log("Function sayHello foi invocada.");
      return "Hello World Solidity";
   }

}
```

### Compilando o Contrato Inteligente

Agora que escrevemos o contrato vamos compilar e ver se tudo correu bem até aqui. ;-)

Para isso basta digitar no terminal:

```bash
$ npx hardhat compile
```

Após a compilação você tera uma mensagem semelhante a essa:

```bash
Compiled 2 Solidity files successfully
```

Excelente contrato compilado e pronto para uso, mas antes de fazer o delivery na rede local vamos escrever alguns testes para garantir que tudo está fucionando corretamente.

### Testando o contrato inteligente com Testes Unitários

Maravilha, contrato criado e compilado com sucesso, agora vamos escrever alguns testes unitários para garantir que ele realize o que foi programado para fazer, neste caso, retornar uma `string` com o valor **"Hello World Solidity"**.

Para isso vamos criar um novo diretório chamado `test` na raiz do nosso projeto e dentro dele um arquivo chamado `HelloWorld.js`.

```bash
$ mkdir test && cd test
$ touch HelloWorld.js
```

Excelente, agora copie e cole o trecho de código abaixo no arquivo HelloWorld.js, iremos falar dele em seguida.

```javascript
const { expect } = require('chai');

describe('Hello World Contract', function () {
	let HelloWorldContract;
	let helloWorldContractDeployed;

	beforeEach(async function () {
		HelloWorldContract = await ethers.getContractFactory('HelloWorld');
		helloWorldContractDeployed = await HelloWorldContract.deploy();
	});

	describe('Call Function Say Hello', function () {
		it('Should be return Hello World Solidity when call the function sayHello', async function () {
			const helloWorldMessage = await helloWorldContractDeployed.sayHello();
			expect('Hello World Solidity').to.equal(helloWorldMessage);
		});
	});
});
```

Agora no terminal digite `npx hardhat test`. Ao final do teste você poderá ver uma mensagem semelhante a esta:

```bash
Hello World Contract
    Call Function Say Hello
Function sayHello foi invocada.
      ✔ Should be return Hello World Solidity when call the function sayHello (38ms)


  1 passing (734ms)
```

Podemos ver inclusive que na terceira linha a nossa mensagem que enviamos para o console do HardHat pode ser apresentada.

#### Explicando o teste

Agora que o nosso teste passou com sucesso, vamos à explicação sobre o que faz cada linha do teste.

```javascript
const { expect } = require('chai');
```

Realizamos a importação da biblioteca de assertions.

```javascript
describe("Hello World Contract", function () {

  let HelloWorldContract;
  let helloWorldContractDeployed;
```

Apenas definimos uma descrição melhor para o nosso grupo de testes para o contrato e definimos algumas variáveis que usamos mais a frente.

```javascript
beforeEach(async function () {
	HelloWorldContract = await ethers.getContractFactory('HelloWorld');
	helloWorldContractDeployed = await HelloWorldContract.deploy();
});
```

Antes de cada teste realizamos o delivery do nosso contrato.

O `ContractFactory` no ethers.js é uma abstração utilizada para efetuar o deploy de novos contratos, e `HelloWorld` é a factory utilizada para instanciar o nosso contrato.

Após a chamada do `deploy()` nosso `ContractFactory` vai iniciar o deploy do nosso contrato e devolver uma `Promisse` que resolve o nosso contrato. Este sendo o objeto que contém as funções do nosso contrato com a qual podemos interagir.

```javascript
describe("Call Function Say Hello", function ()
```

Define uma descrição para o nosso grupo de testes que podem vir a seguir, no nosso caso apenas um teste.

```javascript
it('Should be return Hello World Solidity when call the function sayHello', async function () {
	const helloWorldMessage = await helloWorldContractDeployed.sayHello();
	expect('Hello World Solidity').to.equal(helloWorldMessage);
});
```

Teste propriamente dito, onde await `helloWorldContractDeployed.sayHello()` resolvemos a promisse com o resultado da chamada a função `sayHello()` dentro do nosso contrato e realizamos a assertion em `expect("Hello World Solidity").to.equal(helloWorldMessage)`.

### Conclusão

Neste artigo pudemos conhecer um pouco melhor a estrutura de um Smart Contract, bem como realizar a criação e teste unitário do nosso primeiro contrato inteligente, o famoso Hello World.

---

E é isso por hoje, pessoal!

Chegamos ao final de mais um artigo, espero que tenha sido útil e que você tenha aprendido algo novo.

Caso tenha alguma dúvida, comentário ou tenha encontrado algum erro, por favor, envie-me um [email](mailto:true.dukescode@gmail.com). Ficarei feliz em ouvir de você.

Se desejar receber novos artigos diretamente em seu e-mail, por favor, assine a nossa Newsletter. E se você já é um assinante, muito obrigado!

Aproveito e deixo um convite para nos conectarmos no [Twitter](https://twitter.com/dukefullstack) e [LinkedIn](https://www.linkedin.com/in/dukefullstack/).

👋 Obrigado por ler até o final e até o próximo artigo !!!


Avançando um pouco mais, neste artigo iremos abortar de maneira mais pratica os fundamentos iniciais do Solidity e a estrutura de um Contrato Inteligente.

Guia completo para iniciantes sobre Solidity - Parte III

Estrutura do Contrato Inteligente

Contrato de armazenamento

License

Pragma

Imports

Assinatura do Contrato

Variáveis de Estado

Funções

Hello World Solidity

Compilando o Contrato Inteligente

Testando o contrato inteligente com Testes Unitários

Explicando o teste


Para este artigo iremos utilizar como referência o [tutorial para iniciantes](https://hardhat.org/tutorial) oficial do Hardhat.

A partir do momento que avançamos no desenvolvimento de DApps criamos Smart Contracts mais complexos, passamos a necessitar de ferramentas que nos auxiliem no desenvolvimento e garantam a testabilidade e segurança de nossos contratos inteligentes, e é ai que entram os ambientes de desenvolvimento.

Assim como em outras linguagens, o Solidity também possui um ambiente de desenvolvimento o Hardhat que por sinal não é o único mas é o foco de nossos estudos.

Você encontra o código fonte do projeto neste [respositório](https://github.com/dukes-code/beginners-guide-to-solidity) sob a branch `#beginners-guide-part-ii`.

### Por que o Hardhat?

Hardhat oferece uma série de benefícios para acelerar o processo de desenvolvimento e teste de Smart Contracts utilizando Solidity e JavaScript ou TypeScript.

Com ele podemos rapidamente compilar, testar, debugar e efetuar o delivery dos nossos Contratos Inteligentes em diversas Blockchains. Como ambiente de desenvolvimento ele nos auxilia na automação de tarefas recorrentes como a execução de testes unitários.

Por padrão o Hardhat vem com uma rede local do Ethereum para desenvolvimento, esta rede possui funcionalidades focadas no Solidity em específico debug, stack trace, console.log() e mensagens claras e explícitas quando as transações falham.

Seu ecossistema e comunidade ativa garantem a existência de muitos plugins disponibilizados pelos desenvolvedores para atribuir ainda mais recursos, como a cobertura de código, integração com Ganache, live reload com file watcher e muitos outros.

Utilizando o CLI podemos ainda criar tasks e plugins próprios para a execução de ações mais complexas, como por exemplo, efetuar o delivery do contrato em mais de uma Blockchain sequencialmente.

### Setup do ambiente

Muitas bibliotecas e ferramentas para Ethereum são escritas em JavaScript e com Hardhat não é diferente. Desta forma iremos inicialmente instalar o Node.js que é o único pré-requisito para sua utilização.

### Instalação do Node.js

Caso você já tenha instalado uma versão do Node.js >= 12.0, pode estar avançando em nosso artigo para o próximo item. Caso não estaremos agora efetuando a instalação para Ubuntu, MacOS e Windows.

#### Ubuntu

Execute os comandos abaixo no terminal:

```bash
$ sudo apt update
$ sudo apt install curl git
$ curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -
$ sudo apt install nodejs
```

#### MacOS

Tenha certeza de possuir o git instalado, caso contrário [siga estas instruções](https://www.atlassian.com/git/tutorials/install-git).

Existe muitas maneiras para efetuar a instalação do Node.js no MacOS. Neste artigo iremos utilizar o [nvm](http://github.com/creationix/nvm). Execute os comandos abaixo no terminal:

```bash
$ curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.35.2/install.sh | bash
$ nvm install 12
$ nvm use 12
$ nvm alias default 12
$ npm install npm --global # Upgrade npm to the latest version
```

#### Windows

A instalação do Node.js no Windows requer a execução de alguns passos manualmente. Para isso iremos efetuar a instalação do git, Node.js 12.x e pm.

Efetue o download dos executáveis através dos links abaixo e a sua instalação ao término do download:

- Instalador do [git para Windows](https://git-scm.com/download/win)
- Instalador do [node-v12.XX.XX-x64.msi](https://nodejs.org/dist/latest-v12.x)

### Atualizando a versão do Node.js

Caso você ja tenha uma versão inferior à 12.0 do Node.js pode realizar o procedimento abaixo para efetuar a atualização de acordo com seu Sistema Operacional.

#### Ubuntu

- Execute o comando `$sudo apt remove nodejs` no terminal para remover o Node.js.
- Escolha a versão do Node.js que deseja instalar por meio deste [link](https://github.com/nodesource/distributions#debinstall) e siga as instruções.
- Execute o comando sudo apt update && sudo apt install nodejs no terminal para instalar o Node.js novamente.

#### MacOS

Você pode utilizar o nvm instalado anteriormente para substituir a versão do Node.js que deseja utilizar. Para atualizar a versão do Node.js para 12.x execute os comandos abaixo no terminal:

```bash
$ nvm install 12
$ nvm use 12
$ nvm alias default 12
$ npm install npm --global #Atualiza o npm para a última versão
```

#### Windows

Você deve seguir as mesmas instruções de antes, só que agora selecionando uma versão mais atualizada. Você pode obter uma lista de versões disponíveis [aqui](https://nodejs.org/en/download/releases/).

### Instalando o Hardhat e criando um projeto vazio

Para efetuar a instalação do Hardhat iremos utilizar o npm CLI. O Node.js package manager é um gerenciador de dependências para projetos que utilizem JavaScript.

Para isso vamos abra a terminal e digite os comandos abaixo:

```bash
$ mkdir beginners-guide-to-solidity
$ cd beginners-guide-to-solidity
$ npm init --yes
$ npm install --save-dev hardhat
```

> **ATENÇÃO:** A instalação do Hardhat pode demorar um pouco pois requer a instalação de algumas dependências do Ethereum JavaScript.

Ao término da instalação do **Hardhat** e suas dependências, execute o comando abaixo no terminal para inicializar o wizard para criação de projetos.

```bash
$ npx hardhat
```

Na lista de opções selecione Create an empty hardhat.config.js com as setas do teclado e então pressione enter.

```bash
$ npx hardhat
888    888                      888 888               888
888    888                      888 888               888
888    888                      888 888               888
8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
888    888 .d888888 888    888  888 888  888 .d888888 888
888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888

Welcome to Hardhat v2.0.0

? What do you want to do? …
  Create a sample project
❯ Create an empty hardhat.config.js
  Quit
```

Assim que o CLI do Hardhat executa, ele procura pelo arquivo `hardhat.config.js`. Este arquivo normalmente fica localizado na raiz do projeto e um arquivo vazio `hardhat.config.js` é suficiente para o funcionamento do Hardhat.

### Arquitetura do Hardhat

Hardhat é construído em torno dos conceitos de tasks e plugins. A maior parte das funcionalidades do Hardhat vem de plugins, como dito anteriormente existe uma grande quantidade de plugins disponíveis e você pode criar seus próprios plugins e disponibilizar para a comunidade agregando assim mais recursos e funcionalidades ao seu projeto.

#### Tasks

Toda vez que você executa o `npx hardhat ...` no terminal automaticamente está utilizando o CLI do Hardhat para invocar uma task. Por exemplo, `npx hardhat compile` é responsável por executar a task de compilação do projeto.

Cada projeto pode possuir uma quantidade de tarefas diferentes uma vez que podemos utilizar plugins diferentes em cada projeto, portanto para ver as tarefas atualmente disponíveis em seu projeto execute `npx hardhat`. Para obter detalhes de utilização da task você pode executar no terminal `npx hardhat help [task]`.

> **DICA:** Podemos criar nossas próprias tasks.

#### Plugins

Por padrão toda vez que criamos um projeto com **Hardhat** alguns plugins vem instalados, porém podemos a qualquer momento efetuar a sua substituição.

Nesta série de artigos iremos utilizar o plugin `hardhat-toolbox`. Ele traz consigo todas as ferramentas necessárias para realizar o desenvolvimento e teste dos nossos contratos e para interagirmos com eles. Sua utilização será abordada mais para frente quando efetivamente estivermos desenvolvendo nossos contratos inteligentes.

Para efetuar a instalação, abra o terminal no diretório raiz do projeto e execute:

```bash
$ npm install --save-dev @nomicfoundation/hardhat-toolbox
```

E para finalizar adicione `require("@nomiclabs/hardhat-waffle");` ao seu arquivo **hardhat.config.js** ficando conforme abaixo.

```javascript
require('@nomicfoundation/hardhat-toolbox');

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
	solidity: '0.8.18',
};
```

### Conclusão

Chegamos ao final deste artigo com o nosso ambiente pronto para iniciar o desenvolvimento e teste dos nossos Contratos Inteligentes. A partir de agora iremos efetivamente criar e testar diversos contratos utilizando Solidity e JavaScript.

---

E é isso por hoje, pessoal!

Chegamos ao final de mais um artigo, espero que tenha sido útil e que você tenha aprendido algo novo.

Caso tenha alguma dúvida, comentário ou tenha encontrado algum erro, por favor, envie-me um [email](mailto:true.dukescode@gmail.com). Ficarei feliz em ouvir de você.

Se desejar receber novos artigos diretamente em seu e-mail, por favor, assine a nossa Newsletter. E se você já é um assinante, muito obrigado!

Aproveito e deixo um convite para nos conectarmos no [Twitter](https://twitter.com/dukefullstack) e [LinkedIn](https://www.linkedin.com/in/dukefullstack/).

👋 Obrigado por ler até o final e até o próximo artigo !!!


Dando continuidade a nossa série, iremos ver neste artigo como preparar o ambiente de desenvolvimento utilizado e inicializar um projeto vazio.

Guia completo para iniciantes sobre Solidity - Parte II

Por que o Hardhat?

Setup do ambiente

Instalação do Node.js

Ubuntu

MacOS

Windows

Atualizando a versão do Node.js

Instalando o Hardhat e criando um projeto vazio

Arquitetura do Hardhat

Tasks

Plugins


Este é o primeiro artigo de uma série intitulada “Um Guia Completo para Iniciantes sobre Solidity”, será apresentado uma compreensão detalhada do ecossistema que envolve o Smart Contract e da Linguagem Solidity com foco na plataforma Ethereum. Esses fundamentos fornecerão conhecimentos básicos sobre o assunto para ajudá-lo a iniciar sua jornada.

Com esta série, meu objetivo é trazer conteúdo completo e compreensivo sobre o tema, que tratarei de forma teórica e prática. O primeiro artigo tratará do entendimento teórico necessário para que os leitores possam começar a construir e operar com contratos utilizando Solidity. A partir do segundo artigo, irei demonstrar como escrever um contrato. Tudo será explicado passo-a-passo, e o único requerimento é um entendimento básico da tecnologia blockchain e da plataforma Ethereum.

🚀 Embarque comigo nesta jornada, onde toda semana teremos novos conteúdos.

### O que é Blockchain?

Uma blockchain é um banco de dados distribuído que é compartilhado entre os nós de uma rede de computadores. Como banco de dados, uma blockchain armazena informações eletronicamente em formato digital. Blockchains são mais conhecidos por seu papel crucial em sistemas de criptomoedas, como Bitcoin, Ethereum e muitas outras. Utilizado comumente para manter um registro seguro e descentralizado de transações, assim como um livro razão. A inovação proposta por uma blockchain é a garantia da fidelidade e segurança de um registro de dados e a geração de confiança sem a necessidade de um terceiro confiável.

Por ser imutável a blockchain facilita o processo de registro de transações e rastreamento de ativos em uma rede de negócios. Um ativo pode ser algo tangível (uma casa, carro, dinheiro, terreno, etc) ou intangível (propriedade intelectual, patentes, direitos autorais, marca, etc). Praticamente qualquer coisa de valor pode ser rastreada e negociada em uma rede blockchain, reduzindo riscos e reduzindo custos para todos os envolvidos.

Um banco de dados geralmente estrutura seus dados em tabelas, enquanto uma blockchain, como o próprio nome indica, estrutura seus dados em pedaços (blocos) que são encadeados. Essa estrutura de dados inerentemente cria uma linha de tempo irreversível de dados quando implementada em uma natureza descentralizada. Quando um bloco é preenchido, ele é gravado em pedra e se torna parte dessa linha do tempo. Cada bloco na cadeia recebe um carimbo de hora exato quando é adicionado à cadeia.

![blockchain](/img/a-complete-beginners-guide-to-solidity-part-i/blockchain.png 'Blockchain')

_fig. 1 - cadeia de blocos da blockchain_

### O que é Ethereum?

Ethereum é uma plataforma descentralizada capaz de executar contratos inteligentes e aplicações descentralizadas usando a tecnologia blockchain. São aplicações que funcionam exatamente como programadas sem qualquer possibilidade de censura, fraude ou interferência de terceiros, isso porque o contrato é imutável.

Os contratos inteligentes permitem que os participantes façam transações entre si sem uma autoridade central confiável. Os registros de transações são imutáveis, verificáveis ​​e distribuídos com segurança pela rede, dando aos participantes total propriedade e visibilidade dos dados das transações. As transações são enviadas e recebidas por contas Ethereum criadas pelo usuário. Um remetente deve assinar transações e gastar Ether, a criptomoeda nativa da rede Ethereum, como custo de processamento de transações na rede.

A plataforma Ethereum suporta ether ou ETH, além de uma rede de aplicativos descentralizados, também conhecidos como DApps. Os contratos inteligentes, originados na plataforma Ethereum, são um componente central de como a plataforma opera. Muitas finanças descentralizadas (DeFi) e outros aplicativos (DApps) usam contratos inteligentes em conjunto com a tecnologia blockchain.

![ethereum-blockchain](/img/a-complete-beginners-guide-to-solidity-part-i/ethereum-blockchain.png 'Arquitetura da Ethereum Blockchain')

_fig. 2 - arquitetura da ethereum blockchain_

Como criptomoeda, o Ethereum é o segundo em valor de mercado ficando atrás apenas do Bitcoin na data de publicação deste artigo.

### A Ethereum Virtual Machine (EVM)

A Ethereum Virtual Machine é a plataforma de software que os desenvolvedores podem usar para criar aplicativos descentralizados (DApps) na Blockchain do Ethereum. Esta máquina virtual é onde todas as contas Ethereum e contratos inteligentes vivem.

O próprio protocolo Ethereum existe apenas com o propósito de manter a operação contínua, ininterrupta e imutável dessa máquina de estado especial. Em qualquer bloco da cadeia, o Ethereum tem um e apenas um estado 'canônico', e o EVM é o que define as regras para calcular um novo estado válido bloco a bloco.

![ethereum-virtual-machine](/img/a-complete-beginners-guide-to-solidity-part-i/ethereum-virtual-machine.png 'Componentes da Ethereum Virtual Machine')

_fig. 3 - componentes da ethereum virtual machine_

### O que é Smart Contract?

Em 1994, o cientista de computação e criptógrafo Nick Szabo introduziu o termo _**“smart contract”**_, idealizando uma representação digital de contratos tradicionais, com o objetivo de minimizar a necessidade de confiança em intermediários.

> “A smart contract is a computerized transaction protocol that executes the terms of a contract.” — Szabo, 1994

Smart contracts, ou contratos inteligentes em português, são protocolos computacionais que agem independentemente para executar propósitos específicos. Eles nada mais são do que um conjunto de código, que seguem a lógica if-this-then-that (se-isso-então-aquilo), ou seja, quando algum evento acontece, ele desencadeia uma reação pré-determinada.

![smart-contract-interaction](/img/a-complete-beginners-guide-to-solidity-part-i/smart-contract-interaction.png 'Interação com contratos inteligentes')

_fig. 4 - interação com contratos inteligentes_

Na prática, os participantes não escrevem um novo código toda vez que desejam solicitar um cálculo no EVM. Em vez disso, os desenvolvedores de aplicativos carregam programas (trechos de código reutilizáveis) no estado EVM e os usuários fazem solicitações para executar esses trechos de código com parâmetros variados.

Em um nível muito básico, você pode pensar em um contrato inteligente como uma espécie de máquina de venda automática: um script que, quando chamado com certos parâmetros, executa algumas ações ou cálculos se determinadas condições forem satisfeitas. Por exemplo, um contrato inteligente de fornecedor simples pode criar e atribuir a propriedade de um ativo digital se o chamador enviar ether para um destinatário específico.

Qualquer desenvolvedor pode criar um contrato inteligente e torná-lo público na rede, usando o blockchain como sua camada de dados, por uma taxa paga à rede. Qualquer usuário pode então chamar o contrato inteligente para executar seu código, novamente por uma taxa paga à rede.

Assim, com contratos inteligentes, os desenvolvedores podem criar e implantar aplicativos e serviços arbitrariamente complexos voltados para o usuário, como: mercados, instrumentos financeiros, jogos etc.

### O que são DApps?

Um aplicativo descentralizado (DApp) é um aplicativo construído em uma rede descentralizada que combina um contrato inteligente e uma interface de usuário front-end. No Ethereum, os contratos inteligentes são acessíveis e transparentes – como APIs abertas – para que seu DApp possa até incluir um contrato inteligente escrito por outra pessoa.

Um DApp tem seu código de back-end sendo executado em uma rede ponto a ponto descentralizada. Compare isso com um aplicativo em que o código de back-end está sendo executado em servidores centralizados.

Um DApp pode ter código de front-end e interfaces de usuário escritas em qualquer idioma (assim como um aplicativo) para fazer chamadas para seu back-end. Além disso, seu frontend pode ser hospedado em armazenamento descentralizado, como IPFS.

Depois que os contratos inteligentes são implantados na rede, você não pode alterá-los. Os DApps podem ser considerado descentralizado porque são controlados pela lógica escrita no contrato, não por um indivíduo ou empresa. Isso também significa que você precisa projetar seus contratos com muito cuidado e testá-los completamente.

![app-vs-dapp](/img/a-complete-beginners-guide-to-solidity-part-i/app-vs-dapp.png 'Diferença entre aplicativos e DApps')

_fig. 5 - diferença entre a arquitatura de app e dapp_

Embora o Bitcoin possa ser chamado de primeiro dApp, o Ethereum se tornou o principal motor de crescimento do ecossistema dApp. Isso ocorre em grande parte por causa de seus contratos inteligentes, efeito de rede e base de usuários. À medida que o mercado de finanças descentralizadas (DeFi) expande seus casos de uso e adoção, os dApps apresentam uma rampa essencial para novos públicos, implantando interfaces de usuário que emulam aplicativos da Web convencionais enquanto acessam os novos recursos do blockchain. Ao fazer isso, os dApps estão expandindo de várias maneiras a funcionalidade da Internet por meio do blockchain.

Independentemente da blockchain subjacente em uso, o interesse em dApps está crescendo rapidamente – e o movimento está apenas começando. À medida que o blockchain continua a se desenvolver em ritmo acelerado, é provável que finanças, jogos, mercados online e mídias sociais se tornem dApps baseados em blockchain.

### Ok, mas e o Solidity?

Solidity é uma linguagem de alto nível e orientada a contratos, desenhada com o propósito de facilitar a criação de Smart Contracts. É influenciada por C++, Python e Javascript com o objetivo de facilitar a programação de Smart Contracts na Ethereum Virtual Machine (EVM).

Esses Smart Contracts ou, em português, Contratos Inteligentes. São programas que possuem regras e informações para o desenvolvimento de um produto ou serviço.

A linguagem recém-desenvolvida ganhou um papel significativo na estrutura de contratos da Ethereum, que é de grande importância na tecnologia blockchain. De acordo com Gavin Wood, um dos criadores da Solidity, escrever um Smart Contract é relativamente simples para quem tem experiências com programação, apesar dessa aplicação ser operada dentro de uma blockchain. Em essência, Solidity facilita o desenvolvimento de Smart Contracts no Ethereum e, embora não seja a única linguagem, foi a primeira, a mais versátil.

#### Prós do Solidity

Solidity tem vários pontos fortes que ajudaram a transformar o Ethereum no que ele é hoje. Por um lado, ele foi projetado para ser bastante simples de usar por qualquer pessoa com um conhecimento básico de linguagens de programação como Javascript ou C++.

Por outro lado, seus contratos inteligentes são construídos em uma blockchain, portanto, não podem ser alterados ou excluídos. Isso significa que o Ethereum é uma maneira muito segura de fazer o que foi projetado para fazer - transferir qualquer coisa de valor, usando os tokens Ether nativos ou os tokens ERC-20 compatíveis, para pagar por essas transações.

Solidity permite construir contratos inteligentes seguros, transparentes e confiáveis. Se implementados corretamente, podem aumentar a eficiência operacional, reduzir a administração de custos e a dependência de terceiros.

Solidity é uma das linguagens de programação blockchain mais populares hoje para a cadeia Ethereum e EVM, fornece bastante documentação de código aberto sobre como os aplicativos funcionam e vários casos de uso, a partir daí, você pode facilmente criar aplicativos mais complexos.

Por exemplo, se você está construindo um DEX, você pode clonar completamente o código-fonte da Uniswap e adicionar recursos mais inovadores em sua plataforma, como Liquidity Farming, Lending, etc.

#### Limitações do Solidity

Como o Ethereum é executado na tecnologia Blockchain, ele não consegue coletar e atualizar informações rapidamente no sistema, exceto por meio de operações de negociação. Isso pode ser um grande problema quando se trata de fatores como dados de volatilidade, como o preço dos pares de moedas (Forex).

Outra grande desvantagem que pode ser vista no Solidity é essa imaturidade (quando comparado com linguagens mais antigas como C ou Java). Para os desenvolvedores, isso significa que pode haver muito poucas bibliotecas e referências, tornando o aprendizado do Solidity uma tarefa assustadora para iniciantes.

A imutabilidade é uma grande vantagem, mas em alguns casos pode ser uma desvantagem. Por exemplo, depois que o contrato é feito, ele não pode ser modificado, não se pode adicionar recursos a ele.

Os erros não podem ser corrigidos, as transações não podem ser revertidas e as explorações de falhas só podem ser corrigidas atualizando o código Ethereum – o que requer a participação de nós individuais que nem sempre estão disponíveis, pelo menos não rapidamente.

Um hack DAO de 2016 que drenou US$ 60 milhões em 2016 usando uma vulnerabilidade EVM chamada reentrancy - uma de várias explorações conhecidas - assim como foi um problema com o hack de 27 de agosto de 2021 que causou um fork na blockchain Ethereum. Em ambos os casos, a exploração era conhecida e uma correção havia sido lançada quando foi explorada.

Em julho, a maior exchange de criptomoedas dos EUA, a Coinbase, lançou uma ferramenta chamada Solidify, que é usada para detectar e classificar riscos de contratos inteligentes, uma auditoria automatizada. Como o nome da ferramenta sugere, seu objetivo é melhorar os contratos inteligentes Solidity, encontrando possíveis falhas – algo que a Coinbase faz em sua revisão rigorosa, mas demorada, de protocolos cujos tokens está considerando listar.

#### Salário médio de um desenvolvedor Solidity

Mas primeiro, por que você investiria horas do seu precioso tempo aprendendo a desenvolver em Solidity?

De acordo com [cryptocurrencyjobs.co](http://cryptocurrencyjobs.co/), o salário base médio de um [desenvolvedor Solidity](https://cryptocurrencyjobs.co/salaries/solidity-developer/) varia de US$ 125.000 a US$ 145.000 anuais.

Dado o crescimento explosivo do setor de criptoativos como um todo, é natural imaginar que os desenvolvedores que dominem a linguagem Solidity sejam cada vez mais procurados.

#### Curva de aprendizagem

Solidity é o que chamamos de linguagem de programação orientada a objetos (OOP) de alto nível desenvolvida e usada principalmente pela blockchain Ethereum. As OOPs permitem que os desenvolvedores construam programas usando trechos de código pré-construídos.

O Solidity foi projetado para ser particularmente amigável para qualquer pessoa com familiaridade básica com outras linguagens de programação mais populares, incluindo C++, Java, JavaScript e Python. Isso significa que pessoas com experiência nos conceitos gerais de programação e linguagens de programação mencionadas levariam menos tempo para aprender Solidity. Isso pode levar de três a seis meses.

### Conclusão

Neste primeiro artigo da série, pudemos conhecer um pouco mais sobre o que é Blockchain e seufuncionamento, vimos também como é o funcionamento da máquina virtual do Ethereum a EVM, assim como obtivemos os insigts necessários para entender como os contratos inteligentes são executados.

À cerca do Solidity, vimos as vantagens e desvantagens de se aprender essa nova linguagem de programação e como seria importante aprender a construir contratos inteligentes seguros e transparentes para utilizar na construção de DApps.

---

E é isso por hoje, pessoal!

Chegamos ao final de mais um artigo, espero que tenha sido útil e que você tenha aprendido algo novo.

Caso tenha alguma dúvida, comentário ou tenha encontrado algum erro, por favor, envie-me um [email](mailto:true.dukescode@gmail.com). Ficarei feliz em ouvir de você.

Se desejar receber novos artigos diretamente em seu e-mail, por favor, assine a nossa Newsletter. E se você já é um assinante, muito obrigado!

Aproveito e deixo um convite para nos conectarmos no [Twitter](https://twitter.com/dukefullstack) e [LinkedIn](https://www.linkedin.com/in/dukefullstack/).

👋 Obrigado por ler até o final e até o próximo artigo !!!


Primeiro artigo de uma série abordando os princípios fundamentais e necessários para a introdução do desenvolvedor no ecossistema Blockchain e desenvolvimento de Aplicações Descentralizadas e Contratos Inteligentes.

Guia completo para iniciantes sobre Solidity - Parte I

O que é Blockchain?

O que é Ethereum?

A Ethereum Virtual Machine (EVM)

O que é Smart Contract?

O que são DApps?

Ok, mas e o Solidity?

Prós do Solidity

Limitações do Solidity

Salário médio de um desenvolvedor Solidity

Curva de aprendizagem


### 1. Introdução

Recentemente falamos sobre a arquitetura e funcionamento do Apache Kafka. Vimos também como executar uma instância de um cluster do Kafka localmente e realizamos alguns testes com o cli, você pode conferir mais neste [artigo](/a-brief-introduction-about-apache-kafka).

Hoje passo aqui para deixar uma dica rápida de como utilizar o Docker Compose para configurar um cluster do Kafka para testes localmente, e com o Kafka-ui iremos gerenciar nosso cluster pela interface web.

### 2. Pré-requisitos

Os pré-requisitos para replicar o que iremos abordar neste artigo são um computador Mac, Linux ou Windows com o Docker e Docker Compose instalados.

Caso você ainda não tenha instalado Docker e Docker Compose, você pode seguir as informações neste outro [artigo](/how-to-install-docker-and-docker-compose-on-ubuntu-22-04) onde tratamos da instalação em um computador Linux com Ubuntu 22.04.

### 3. Arquivo docker-compose.yml

Como já sabemos para trabalhar com o Docker Compose, precisamos de um arquivo yaml para configurar os nossos containers. Sendo assim vamos criar um diretório chamado kafka-cluster-with-ui e dentro dele um arquivo yaml com as configurações de nossos containers:

```bash
$ mkdir kafka-cluster-with-ui && cd kafka-cluster-with-ui
$ touch docker-compose.yml && nano docker-compose.yml
```

Agora vamos adicionar as configurações de nossos containers:

```yaml
---
version: '2'
services:
  zookeeper:
    image: confluentinc/cp-zookeeper:7.2.1
    hostname: zookeeper
    container_name: zookeeper
    ports:
      - '2181:2181'
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000

  broker:
    image: confluentinc/cp-server:7.2.1
    hostname: broker
    container_name: broker
    depends_on:
      - zookeeper
    ports:
      - '9092:9092'
      - '9101:9101'
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: 'zookeeper:2181'
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://broker:29092,PLAINTEXT_HOST://localhost:9092
      KAFKA_METRIC_REPORTERS: io.confluent.metrics.reporter.ConfluentMetricsReporter
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
      KAFKA_CONFLUENT_LICENSE_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_CONFLUENT_BALANCER_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
      KAFKA_JMX_PORT: 9101
      KAFKA_JMX_OPTS: -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false -Djava.rmi.server.hostname=kafka0 -Dcom.sun.management.jmxremote.rmi.port=9101
      KAFKA_CONFLUENT_SCHEMA_REGISTRY_URL: http://schema-registry:8081
      CONFLUENT_METRICS_REPORTER_BOOTSTRAP_SERVERS: broker:29092
      CONFLUENT_METRICS_REPORTER_TOPIC_REPLICAS: 1
      CONFLUENT_METRICS_ENABLE: 'true'
      CONFLUENT_SUPPORT_CUSTOMER_ID: 'anonymous'

  schema-registry:
    image: confluentinc/cp-schema-registry:7.2.1
    hostname: schema-registry
    container_name: schema-registry
    depends_on:
      - broker
    ports:
      - '8081:8081'
    environment:
      SCHEMA_REGISTRY_HOST_NAME: schema-registry
      SCHEMA_REGISTRY_KAFKASTORE_BOOTSTRAP_SERVERS: 'broker:29092'
      SCHEMA_REGISTRY_LISTENERS: http://0.0.0.0:8081

  connect:
    image: cnfldemos/cp-server-connect-datagen:0.5.3-7.1.0
    hostname: connect
    container_name: connect
    depends_on:
      - broker
      - schema-registry
    ports:
      - '8083:8083'
    environment:
      CONNECT_BOOTSTRAP_SERVERS: 'broker:29092'
      CONNECT_REST_ADVERTISED_HOST_NAME: connect
      CONNECT_GROUP_ID: compose-connect-group
      CONNECT_CONFIG_STORAGE_TOPIC: docker-connect-configs
      CONNECT_CONFIG_STORAGE_REPLICATION_FACTOR: 1
      CONNECT_OFFSET_FLUSH_INTERVAL_MS: 10000
      CONNECT_OFFSET_STORAGE_TOPIC: docker-connect-offsets
      CONNECT_OFFSET_STORAGE_REPLICATION_FACTOR: 1
      CONNECT_STATUS_STORAGE_TOPIC: docker-connect-status
      CONNECT_STATUS_STORAGE_REPLICATION_FACTOR: 1
      CONNECT_KEY_CONVERTER: org.apache.kafka.connect.storage.StringConverter
      CONNECT_VALUE_CONVERTER: io.confluent.connect.avro.AvroConverter
      CONNECT_VALUE_CONVERTER_SCHEMA_REGISTRY_URL: http://schema-registry:8081
      # CLASSPATH required due to CC-2422
      CLASSPATH: /usr/share/java/monitoring-interceptors/monitoring-interceptors-7.2.1.jar
      CONNECT_PRODUCER_INTERCEPTOR_CLASSES: 'io.confluent.monitoring.clients.interceptor.MonitoringProducerInterceptor'
      CONNECT_CONSUMER_INTERCEPTOR_CLASSES: 'io.confluent.monitoring.clients.interceptor.MonitoringConsumerInterceptor'
      CONNECT_PLUGIN_PATH: '/usr/share/java,/usr/share/confluent-hub-components'
      CONNECT_LOG4J_LOGGERS: org.apache.zookeeper=ERROR,org.I0Itec.zkclient=ERROR,org.reflections=ERROR

  kafka-ui:
    image: provectuslabs/kafka-ui
    hostname: kafka-ui
    container_name: kafka-ui
    ports:
      - '8080:8080'
    depends_on:
      - zookeeper
      - broker
      - schema-registry
      - connect
    restart: always
    environment:
      - KAFKA_CLUSTERS_0_NAME=local
      - KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS=broker:29092
      - KAFKA_CLUSTERS_0_METRICS_PORT=9101
      - KAFKA_CLUSTERS_0_SCHEMAREGISTRY=http://schema-registry:8081
      - KAFKA_CLUSTERS_0_KAFKACONNECT_0_NAME=first
      - KAFKA_CLUSTERS_0_KAFKACONNECT_0_ADDRESS=http://connect:8083
      - DYNAMIC_CONFIG_ENABLED='true'
```

Estamos implantando neste arquivo uma instância do `zookeeper`, um `broker`do kafka, uma instância do `schema-registry`, um do `kafka-connect` e para gerenciar todo o cluster o `kafka-ui`.

Para subir nosso cluster executamos o comando abaixo:

```bash
$ docker compose -f docker-compose.yml up -d
```

Podemos então executar o comando abaixo para verificar se o cluster está funcionando:

```bash
$ docker compose -f docker-compose.yml ps
```

Iremos obter uma saída semelhante a seguir:

```bash
NAME                IMAGE                                             COMMAND                  SERVICE             CREATED              STATUS              PORTS
broker              confluentinc/cp-server:7.2.1                      "/etc/confluent/dock…"   broker              About a minute ago   Up About a minute   0.0.0.0:9092->9092/tcp, :::9092->9092/tcp, 0.0.0.0:9101->9101/tcp, :::9101->9101/tcp
connect             cnfldemos/cp-server-connect-datagen:0.5.3-7.1.0   "/etc/confluent/dock…"   connect             About a minute ago   Up About a minute   0.0.0.0:8083->8083/tcp, :::8083->8083/tcp, 9092/tcp
kafka-ui            provectuslabs/kafka-ui                            "/bin/sh -c 'java --…"   kafka-ui            About a minute ago   Up About a minute   0.0.0.0:8080->8080/tcp, :::8080->8080/tcp
schema-registry     confluentinc/cp-schema-registry:7.2.1             "/etc/confluent/dock…"   schema-registry     About a minute ago   Up About a minute   0.0.0.0:8081->8081/tcp, :::8081->8081/tcp
zookeeper           confluentinc/cp-zookeeper:7.2.1                   "/etc/confluent/dock…"   zookeeper           About a minute ago   Up About a minute   2888/tcp, 0.0.0.0:2181->2181/tcp, :::2181->2181/tcp, 3888/tcp
```

Podemos então agora acessar o kafka-ui em [http://localhost:8080](http://localhost:8080).

![kafka-ui-overview](/img/setting-up-a-kafka-environment-for-test-with-kafka-ui/kafka-ui-overview.gif 'Visão geral do kafka-ui')

_fig. 1 - visão geral do kafka-ui_

### 4. Executando testes

Agora que já estamos com acesso ao cluster pela interface web, vamos criar um `tópico` conforme a seguir e publicar algumas mensagens para que possamos consumir pelo console utilizando o `kafka-console-consumer`.

![kafka-ui-creating-topic](/img/setting-up-a-kafka-environment-for-test-with-kafka-ui/kafka-ui-creating-topic.gif 'Criação do tópico utilizando o kafka-ui')

_fig. 2 - criação do tópico utilizando o kafka-ui_

Neste [artigo](/a-brief-introduction-about-apache-kafka) vimos como realizar o download do apache kafka e utilizar o cli para se comunicar com o broker, para mais detalhes basta consulta-lo novamente.

Agora vamos nos conectar ao nosso `broker` e consumir as mensagens do tópico recém-criado.

Para isso abra o terminal e digite o comando a seguir:

```bash
$ ./bin/kafka-console-consumer.sh --topic posts-like --from-beginning --bootstrap-server localhost:9092
```

Voltemos então para nossa interface web para publicar algumas mensagens e acompanhar o consumo pelo nosso `consumer` no console.

![kafka-ui-producing-messages](/img/setting-up-a-kafka-environment-for-test-with-kafka-ui/kafka-ui-producing-messages.gif 'Produzindo mensagens pelo kafka-ui')

_fig. 3 - produzindo mensagens pelo kafka-ui_

No próximo teste iremos fazer o inverso, iremos publicar mensagnes pelo nosso console e acompanhar o consumo pelo kafka-ui.

Para isso inicie o nosso `produtor` com o comando a seguir:

```bash
$ ./bin/kafka-console-producer.sh --topic posts-like --bootstrap-server localhost:9092
```

![kafka-ui-consuming-messages](/img/setting-up-a-kafka-environment-for-test-with-kafka-ui/kafka-ui-consuming-messages.gif 'Consumindo mensagens pelo kafka-ui')

_fig. 4 - consumindo mensagens pelo kafka-ui_

### Conclusão

Neste artigo reallizamos a instalação de um ambiente completo do Apache kafka com recursos além dos utilizados aqui, mas com os recursos mínimos para aplicações de grande escala, tudo isso utilizando apenas o Docker Compose.

Vimos também como realizar a administração do nosso cluster a partir da interface web utilizando a ferramenta Open-Source kafka-ui.

Continue nos acompanhando pois nos próximos artigos iremos criar uma aplicação completa em microserviços utilizando tudo o que vimos até aqui além do `schema-registry` e `kafka-connect`.

---

E é isso por hoje, pessoal!

Chegamos ao final de mais um artigo, espero que tenha sido útil e que você tenha aprendido algo novo.

Caso tenha alguma dúvida, comentário ou tenha encontrado algum erro, por favor, envie-me um [email](mailto:true.dukescode@gmail.com). Ficarei feliz em ouvir de você.

Se desejar receber novos artigos diretamente em seu e-mail, por favor, assine a nossa Newsletter. E se você já é um assinante, muito obrigado!

Aproveito e deixo um convite para nos conectarmos no [Twitter](https://twitter.com/dukefullstack) e [LinkedIn](https://www.linkedin.com/in/dukefullstack/).

👋 Obrigado por ler até o final e até o próximo artigo !!!


Bem vindo a mais um tutorial turma. Desta vez iremos utilizar o Docker Compose para configurar um cluster do Kafka com Kafka-ui para testes local e com gerenciamento web do cluster.

Configurando um cluster do Kafka para testes com Docker Compose e Kafka-ui

1. Introdução

2. Pré-requisitos

3. Arquivo docker-compose.yml

4. Executando testes


### 1. Introdução ao Apache Kafka

O Apache Kafka é uma plataforma de streaming distribuída que é usada para construir pipelines de dados em tempo real e aplicativos de streaming. É um sistema de mensagens de alto desempenho e baixa latência que é projetado para lidar com grandes volumes de dados e permitir a troca de dados em tempo real entre aplicativos.

O Apache Kafka foi originalmente desenvolvido pelo LinkedIn e, posteriormente, foi doado para a Apache Software Foundation. Ele é escrito em Java e é uma plataforma de código aberto que pode ser executada em uma variedade de sistemas operacionais, incluindo Linux, macOS e Windows.

A plataforma é frequentemente usada em casos de uso como análise de dados em tempo real, processamento de stream, integração de sistemas, agregação de logs e métricas, entre outros.

O Kafka é baseado em uma arquitetura distribuída, o que significa que ele é capaz de escalar horizontalmente e lidar com grandes quantidades de dados em tempo real. É também altamente tolerante a falhas, com recursos de replicação e failover integrados.

Em resumo, o Apache Kafka é uma plataforma de streaming distribuída que oferece alta escalabilidade, baixa latência e tolerância a falhas para casos de uso de streaming de dados em tempo real.

### 2. Partes que compõem o Apache Kafka

O Apache Kafka é composto por várias partes que trabalham juntas para fornecer um pipeline de dados escalável e de baixa latência para processamento e transmissão de dados em tempo real. Essas partes incluem produtores, consumidores, tópicos, partições, brokers, ZooKeeper e grupos de consumidores.

![kafka-architecture](/img/a-brief-introduction-about-apache-kafka/kafka-architecture.jpg 'Arquitetura do Kafka')

_fig. 1 - arquitetura do kafka_

Cada uma dessas partes tem um papel importante no funcionamento do Kafka e na entrega dos dados de forma eficiente e confiável.

- **Producers:** são responsáveis por enviar dados para o Kafka. Eles produzem os dados e os enviam para um ou mais tópicos do Kafka.

- **Consumers:** são responsáveis por receber dados do Kafka. Eles se inscrevem em um ou mais tópicos e consomem os dados produzidos pelos produtores.

- **Consumers Groups:** são grupos de consumidores que compartilham a carga de leitura de partições de um tópico. O objetivo é permitir que os consumidores possam se balancear e escalonar horizontalmente conforme necessário.

- **Topics:** são fluxos de dados semelhantes a uma categoria ou um feed de notícias. Eles representam as categorias ou áreas de interesse dos dados no Kafka.

- **Partitions:** são divisões lógicas de um tópico no Kafka. Elas são usadas para distribuir e paralelizar o processamento de dados em vários nós do Kafka Cluster.

- **Brokers:** são os nós do Kafka Cluster que armazenam e distribuem as partições do tópico em diferentes nós do cluster. Cada nó do Kafka é um broker que executa uma ou mais instâncias do Kafka.

- **ZooKeeper(Opcional):** é um serviço de coordenação distribuída que é usado para gerenciar e manter a configuração do Kafka Cluster. O ZooKeeper é responsável por armazenar informações de configuração, monitorar a disponibilidade dos nós do Kafka e coordenar o processo de failover.

No geral, todas essas partes trabalham juntas para criar um sistema distribuído de streaming de dados que pode lidar com grandes volumes de dados em tempo real, oferecendo alta escalabilidade, baixa latência e tolerância a falhas.

### 3. Tópicos e Partições no Apache Kafka

De forma geral, o Kafka armazena registros em tópicos. Portanto, quando enviamos um novo registro para o Kafka, devemos decidir o nome do tópico para onde ele deve ser armazenado. Também, devmos fornecer o nome de um tópico para receber e processar registros do Kafka.

Quando falmos de registros, eventos, mensagens estamos essencialmente falando da mesma informação. No decorrer deste post iremos chamar as informações enviadas e coletadas dos tópicos de mensagens.

Pense nos tópicos como a fila ou tabela em que você deseja armazenar seus dados. Gostei bastante da comparação entre tópicos e tabelas de banco de dados feita nesta apresentação de [Robin Moffatt](https://www.youtube.com/watch?v=xy6jNKI3tKU&t=473s). Por exemplo, você tem um tópico que contém pedidos, o que é bastante razoável para comparar com uma tabela de banco de dados que contém informações de pedidos. Suas aplicações podem, então, usar este tópico para enviar informações sobre pedidos conforme eles chegam enquanto serviços downstream os processam.

Na terminologia do Kafka, os `produtores` enviam novas mensagens, enquanto os `consumidores` as lêem mais tarde (embora possivelmente quase instantaneamente). Os `tópicos` conectam `produtores` e `consumidores` criando uma ponte entre eles.

![kafka-producer-topic-consumer](/img/a-brief-introduction-about-apache-kafka/kafka-producer-topic-consumer.png 'Comunicação entre produtores, tópicos e consumidores')

_fig. 2 - fluxo de comunicação entre produtores, tópicos e consumidores_

Um `tópico` é uma uma categoria para as mensagens que estão sendo transmitidas. Cada informação é associada a um `tópico` específico, que é definido por um **nome**. Quando um `produtor` envia uma mensagem, ele especifica o **nome** do `tópico` ao qual essa mensagem está relacionada.

Por sua vez, os `consumidores` podem se inscrever em um ou mais `tópicos`, de acordo com seus interesses. Isso significa que eles receberão apenas as mensagens que estão relacionadas aos `tópicos` nos quais se inscreveram. Por exemplo, na imagem a seguir percebemos que os `consumidores` se conectaram apenas ao `tópico` _**ORDERS**_.

![kafka-producer-topic-consumer-detailed](/img/a-brief-introduction-about-apache-kafka/kafka-producer-topic-consumer-detailed.png 'Comunicação entre produtores, tópicos e consumidores em detalhe')

_fig. 3 - fluxo de comunicação entre produtores, tópicos e consumidores no detalhe_

Embora as duas imagens anteriores descrevam bem o que são `tópicos`, elas fornecem apenas uma visão geral. Para compreender melhor o funcionamento de um tópico, é necessário investigar mais a fundo.

Um `tópico` é constituido por multiplas `queues internas` chamadas de `partições`, que armazenam as mensagens enviadas para o Kafka. Por exemplo:

![kafka-topic-partitions](/img/a-brief-introduction-about-apache-kafka/kafka-topic-partitions.png 'Tópico no detalhe com suas partições')

_fig. 3 - organização de partições dentro do tópico_

Cada `partição` em um `tópico` mantém sua própria ordem, o que é fundamental para a escalabilidade do Kafka. Os `produtores` podem enviar mensagens para qualquer `partição` em um `tópico`, escolhendo uma `partição` com base na `chave da mensagem` ou especificando explicitamente uma `partição`. Esse método de divisão de mensagens permite que cada `partição` cresça em ritmos semelhantes.

Ao se inscrever em um `tópico`, os `consumidores` são designados para receber mensagens de algumas das `partições` desse `tópico`.

Cada `consumidor` recebe mensagens de uma `partição` que mantém a ordem em que foram produzidos. Essa ordem possibilita o uso de vários `consumidores` para processar eventos de um único `tópico`, o que melhora o desempenho e a disponibilidade (desde que implementado corretamente).

![kafka-topic-partitions-producers-consumers](/img/a-brief-introduction-about-apache-kafka/kafka-topic-partitions-producers-consumers.png 'Diagrama completo de comunicação entre produtores, tópicos e consumidores')

_fig. 4 - diagrama completo de comunicação entre produtores, tópicos e consumidores_

### 4. Produtores e Consumidores no Apache Kafka

Os `produtores` são responsáveis por gerar o código do cliente Kafka, este por sua vez é utilizado para enviar as mensagens para os `tópicos`.

Esses clientes diminuem significativamente a complexidade de uso do Kafka, já que eles lidam com problemas como pooling de conexões e buffer de rede. Com isso, é possível interagir com o Kafka fazendo uso de uma pequena quantidade de APIs.

> Em artigos futuros iremos utilizar o Java para implementar os `produtores` e `consumidores`.

O diagrama a seguir ilustra como um `produtor` envia uma mensagem para um `broker`, que, por sua vez, o registra em uma das `partições` dos `tópicos`.

![kafka-producer-simple](/img/a-brief-introduction-about-apache-kafka/kafka-producer-simple.png 'Diagrama de iteração entre produtor, broker e tópico')

_fig. 5 - diagrama de comunicação entre produtor, broker e tópico_

Os `consumidores` são responsáveis por gerar o código do cliente Kafka para ler as `mensagens` dos `tópicos`, atuando na extremidade oposta em relação aos `produtores` e aproveitando as mesmas funcionalidades, como pooling de conexões e buffer de rede.

O diagrama abaixo exemplifica a interação entre um `consumidor` e um `broker`, em que o `consumidor` recebe as mensagens armazenadas em um `tópico`.

![kafka-consumer-broker-simple](/img/a-brief-introduction-about-apache-kafka/kafka-consumer-broker-simple.png 'Diagrama de iteração entre consumidor, broker e tópico')

_fig. 6 - diagrama de comunicação entre consumidor, broker e tópico_

### 5. Offset no Apache Kafka

Cada mensagem armazenada em uma `partição` tem a ela atribuída um `offset` que indica a distância dela em relação ao início da `partição`.

Adicionar novas mensagens aumenta o `offset`, garantindo que as mensagens mais recentes sempre terão um `offset` maior do que as mensagens mais antigos (com base no tempo em que foram armazenadas).

![kafka-offset-in-partition](/img/a-brief-introduction-about-apache-kafka/kafka-offset-in-partition.png 'Atribuição de offset em uma partição')

_fig. 7 - atribuição de offset em uma partição_

Os `offsets` não tão importantes ao se persistir novas mensagens, pois essa parte é toda tratada pelo Kafka. No entanto, o conceito desempenha um papel importante ao consumir as mensagens.

Os `consumidores` usam `offsets` das `partições` para acompanhar quais mensagens foram processadas. À medida que ele busca mensagens e realiza o processamento necessário, precisa de alguma formar marcar os `offsets` dessas mensagens, para que o `consumidor` saiba de qual ponto deve retomar a busca por mensagens em caso de falhas.

#### 5.1 Commit dos offsets

O processo de acompanhamento dos `offsets` de um `consumidor` é conhecido como **commit**. Isso significa que o `offset` atual de uma `partição` é **"commitado"** e armazenado.

O `consumidor` não armazena seus `offsets` localmente. Em vez disso, ele os envia para o `broker` do Kafka, que os persiste em disco.

Ao manter os `offsets` remotamente no `broker`, reduzimos o acoplamento entre os clientes `consumidores` dentro do contexto da nossa aplicação. Desta forma é possível iniciar, parar e até mesmo destruir as máquinas que executam os `consumidores` sem impedir a recuperação da nossa aplicação.

É possível inicializar um novo cliente `consumidor` e continuar instantaneamente o processamento a partir do ponto em que o `consumidor` anterior parou.

### 6. Consumer Groups, agrupamento de consumidores

Os `consumidores` podem se agrupar em **“grupos de consumidores”**, que determinam quais mensagens cada um receberá. Embora isso possa parecer vago, não há outra maneira curta e sucinta de resumir este assunto.

Em resumo, os grupos de `consumidores` realizam o seguinte:

- Agrupam os consumidores por função
- Compartilham as partições de um tópico entre os consumidores do mesmo grupo

Os grupos de `consumidores`nos permite relacionar um conjunto de `consumidores` que trabalhem juntos para executar uma única função, processo ou tarefa. Cada grupo de `consumidores` processa todas mensagens de um `tópico` independentemente de outros grupos.

Por exemplo, se você tiver um `tópico` que represente dados de vendas, um grupo poderá manter um agregado dos valores de venda enquanto outro passa para um sistema downstream para processamento posterior.

Ambos esses grupos serão executados independentemente e gerenciarão seus `offsets`, mesmo ao se inscreverem no mesmo `tópico`.

O diagrama abaixo ilustra dois grupos de `consumidores` que recebem todas as mensagens armazenadas no `tópico`:

![kafka-consumer-groups-receive-all-records](/img/a-brief-introduction-about-apache-kafka/kafka-consumer-groups-receive-all-records.png 'Consumidores agrupados por função')

_fig. 8 - consumidores agrupados por função_

#### 6.1 Compartilhando as partições de um tópico entre os consumidores do mesmo grupo

Cada `consumidor` dentro de um `grupo de consumidores` é atribuído a um conjunto de `partições` de um `tópico`, garantindo o compartilhamento de mensagens entre o grupo e mantendo a ordem das mensagens em cada `partição`. Esse mecanismo é otimizado mantendo as atribuições de `partições` iguais até a adição de um novo `consumidor` ao grupo.

Nesse momento, o Kafka redistribui as `partições` entre os `consumidores` do grupo, um processo conhecido como **“rebalanceamento”**. Se houver mais `partições` do que `consumidores` em um grupo, os `consumidores` podem ser atribuídos a várias `partições`.

O diagrama ilustra o compartilhamento de `partições` em um único `grupo de consumidores`:

![kafka-consumer-groups-multiple-consumers-in-group](/img/a-brief-introduction-about-apache-kafka/kafka-consumer-groups-multiple-consumers-in-group.png 'Compartilhamento de partições entre os consumidores')

_fig. 9 - compartilhamento de partições entre os consumidores_

A inclusão de outro `grupo de consumidores` não afeta a atribuição dos grupos existentes, como mostrado abaixo:

![kafka-consumer-groups-multiple-consumers-in-multiple-groups](/img/a-brief-introduction-about-apache-kafka/kafka-consumer-groups-multiple-consumers-in-multiple-groups.png 'Novo grupo de consumidores não afeta a atribuição dos grupos existentes')

_fig. 10 - novo grupo de consumidores não afeta a atribuição dos grupos existentes_

Quando um novo `consumidor` é adicionado a um grupo, o Kafka realiza um rebalanceamento. Durante esse processo, as `partições` de cada `tópico` atribuídas ao grupo são redistribuídas entre todos os `consumidores` do grupo de maneira uniforme, garantindo que cada `consumidor` tenha aproximadamente o mesmo número de `partições` para consumir.

Esse processo ajuda a garantir o equilíbrio de carga entre os `consumidores` do grupo e otimiza o desempenho do Kafka.

![kafka-consumer-groups-rebalance](/img/a-brief-introduction-about-apache-kafka/kafka-consumer-groups-rebalance.png 'Redistribuição das partições entre os consumidores do grupo')

_fig. 11 - redistribuição das partições entre os consumidores do grupo_

### 7. Executando um teste com o Apache Kafka utilizando o cli

Para executarmos um teste simples rodando um `broker` do kafka localmente precisaremos ter instalado o Java JDK 8 ou superior.

Realizae o download do [Apache Kafka](https://kafka.apache.org/downloads), no momento em que escrevo este artigo a versão mais recente é a [3.4.0 Scala 2.13](https://downloads.apache.org/kafka/3.4.0/kafka_2.13-3.4.0.tgz).

Para demonstração iremos utilizar o sistema operacional Linux Ubuntu 22.04. Portanto para efetuar o download digite o comando abaixo:

```bash
$ wget https://downloads.apache.org/kafka/3.4.0/kafka_2.13-3.4.0.tgz
```

Depois de finalizar o download descompacte os arquivos e acesse a pasta `kafka_2.13-3.4.0` com os comandos abaixo:

```bash
$ tar -xzf kafka_2.13-3.4.0.tgz
$ cd kafka_2.13-3.4.0
```

Agora inicialize o ZooKeeper e em seguida o Apache Kafka com os comandos abaixo:

```bash
$ ./bin/zookeeper-server-start.sh config/zookeeper.properties
$ ./bin/kafka-server-start.sh config/server.properties
```

![zookeeper-kafka-broker-running](/img/a-brief-introduction-about-apache-kafka/zookeeper-kafka-broker-running.png 'Zookeeper e Apache Kafka em execução')

_fig. 12 - zookeeper e apache kafka em execução_

Vamos então criar o nosso `tópico` para que possamos publicar algumas mensagens e posteriormente consumir essas mensagens.

Para isso no terminal digite o comando abaixo:

```bash
$ ./bin/kafka-topics.sh --create --bootstrap-server localhost:9092 --replication-factor 1 --partitions 1 --topic LIKES_POST
```

Para verificar se o tópico foi criado com sucesso, digite o comando abaixo:

```bash
$ ./bin/kafka-topics.sh --list --bootstrap-server localhost:9092
```

A saída será o nome do nosso `tópico` _**LIKES_POST**_.

Agora iniciamos o nosso `produtor` com o comando abaixo:

```bash
$ ./bin/kafka-console-producer.sh --broker-list localhost:9092 --topic LIKES_POST
```

Este comando libera a E/S para digitar as mensagens que poderão ser inseridas a cada linha, como abaixo:

```bash
>
```

Agora inicie o `consumidor` com o comando a seguir:

```bash
$ ./bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic LIKES_POST --from-beginning
```

Vamos então inputar algumas mensagens e acompanhar o consumidor.

![producer-consumer-interaction](/img/a-brief-introduction-about-apache-kafka/producer-consumer-interaction.gif 'Interação entre produtor e consumidor')

_fig. 12 - interação entre produtor e consumidor_

### Conclusão

O Apache Kafka é uma plataforma distribuída de streaming que permite a troca de mensagens em tempo real entre aplicações de maneira escalável e confiável. Sua arquitetura distribuída garante alta disponibilidade, tolerância a falhas e escalabilidade horizontal.

Os `tópicos` do Kafka permitem organizar as mensagens por assunto, permitindo que as aplicações `consumidoras` obtenham as informações relevantes de acordo com sua necessidade.

Os `produtores e consumidores` são responsáveis por enviar e receber as mensagens para e do Kafka, respectivamente, e os `offsets` são usados pelos `consumidores` para acompanhar o progresso no processamento das mensagens.

O uso de `grupos de consumidores` permite agrupar `consumidores` com a mesma função, compartilhar as `partições` do `tópico` e garantir que cada `consumidor` processe uma parte exclusiva das mensagens.

Com esses conceitos em mente, é possível construir sistemas distribuídos altamente escaláveis e confiáveis usando o Apache Kafka como plataforma de streaming.

---

E é isso por hoje, pessoal!

Chegamos ao final de mais um artigo, espero que tenha sido útil e que você tenha aprendido algo novo.

Caso tenha alguma dúvida, comentário ou tenha encontrado algum erro, por favor, envie-me um [email](mailto:true.dukescode@gmail.com). Ficarei feliz em ouvir de você.

Se desejar receber novos artigos diretamente em seu e-mail, por favor, assine a nossa Newsletter. E se você já é um assinante, muito obrigado!

Aproveito e deixo um convite para nos conectarmos no [Twitter](https://twitter.com/dukefullstack) e [LinkedIn](https://www.linkedin.com/in/dukefullstack/).

👋 Obrigado por ler até o final e até o próximo artigo !!!


Bem vindo a mais um tutorial turma. Desta vez iremos rapidamente compreender a arquitetura e funcionamento do Apache Kafka.

Uma breve introdução sobre Apache Kafka

1. Introdução ao Apache Kafka

2. Partes que compõem o Apache Kafka

3. Tópicos e Partições no Apache Kafka

4. Produtores e Consumidores no Apache Kafka

5. Offset no Apache Kafka

5.1 Commit dos offsets

6. Consumer Groups, agrupamento de consumidores

6.1 Compartilhando as partições de um tópico entre os consumidores do mesmo grupo

7. Executando um teste com o Apache Kafka utilizando o cli


### 1. Introdução

O Docker Compose é uma ferramenta que nos permite definir e executar aplicativos Docker multi-container com facilidade. Com ele, podemos criar, executar e gerenciar aplicativos Docker de maneira fácil e eficiente. O PostgreSQL, por sua vez, é um dos bancos de dados relacionais mais populares do mundo. Ele oferece confiabilidade, escalabilidade e segurança, além de uma ampla variedade de recursos para gerenciamento de dados.

### 2. Instalação do Docker e Docker Compose

Antes de iniciar a configuração do PostgreSQL, é necessário ter o Docker e o Docker Compose instalados na máquina host. Ambos são necessários para criar e gerenciar o container PostgreSQL que armazenará os dados. Verifique a documentação do [Docker](https://docs.docker.com/get-docker/) e do [Docker Compose](https://docs.docker.com/compose/install/) para obter instruções de instalação específicas para o seu sistema operacional.

Se estiver utilizando o Ubuntu 22.04 voce pode seguir as instruções neste outro [post](/how-to-install-docker-and-docker-compose-on-ubuntu-22-04), onde eu explico detalhadamente como realizar a instalação do Docker e Docker Compose.

### 3. Configuração do arquivo docker-compose.yml

O arquivo `docker-compose.yml` é o arquivo de configuração principal do Docker Compose. Ele define todos os serviços que serão executados e suas configurações. Para configurar o serviço PostgreSQL, abra um editor de texto e crie um arquivo chamado `docker-compose.yml`. Em seguida, adicione o seguinte código:

```yaml:docker-compose.yml
version: '3.9'
services:
  postgresql:
    container_name: postgresql-dev
    image: postgres:15-alpine
    restart: always
    user: postgres
    volumes:
      - pgdata:/var/lib/postgresql/data
    command:
      - 'postgres'
      # persist logs inside /var/lib/postgresql/data/log
      # - '-c'
      # - 'logging_collector=on'
      # log all statement execution
      - '-c'
      - 'log_statement=all'
    environment:
      - LC_ALL=C.UTF-8
      - POSTGRES_USER=$POSTGRES_USER
      - POSTGRES_PASSWORD=$POSTGRES_PASSWORD
      - POSTGRES_DB=$POSTGRES_DB
    logging:
      options:
        max-size: 10m
        max-file: '3'
    ports:
      - '15432:5432'
    networks:
      - postgres-dev
  pgadmin:
    container_name: pgadmin-dev
    image: dpage/pgadmin4
    restart: unless-stopped
    volumes:
      - pgadmin:/var/lib/pgadmin
    environment:
      PGADMIN_DEFAULT_EMAIL: $PGADMIN_DEFAULT_EMAIL
      PGADMIN_DEFAULT_PASSWORD: $PGADMIN_DEFAULT_PASSWORD
      PGADMIN_CONFIG_SERVER_MODE: 'False'
    ports:
      - 5050:80
    networks:
      - postgres-dev
volumes:
  pgdata:
    driver: local
    driver_opts:
      o: bind
      type: none
      device: /home/dukefs/docker-volumes/postgresql/dev/data
  pgadmin:
    driver: local
    driver_opts:
      o: bind
      type: none
      device: /home/dukefs/docker-volumes/pgadmin/dev
networks:
  postgres-dev:
    driver: bridge
```

Neste arquivo, definimos um serviço chamado `postgresql` que utiliza a imagem oficial do PostgreSQL. O serviço é reiniciado sempre que o Docker é iniciado e configurado com um usuário, senha e banco de dados personalizados. Por fim, definimos um volume para persistir os dados do PostgreSQL na pasta `/var/lib/postgresql/data` mapeado fisicamente para a máquina host definido pelo volume `pgdata`.

Perceba que criamos um segundo serviço chamado `pgadmin`, que é um serviço de gerenciamento de dados para o PostgreSQL. Este serviço que iremos utilizar para testar a conexão com o PostgreSQL mais à frente.

### 4. Criação dos serviços PostgreSQL e PgAdmin com Docker Compose

Agora que o arquivo `docker-compose.yml` está configurado, podemos criar os serviços com o seguinte comando:

```bash
$ docker compose up -d
```

Este comando irá baixar as imagens necessárias, criar um container para cada serviço com base na imagem e iniciar os serviços.

### 5. Configuração de variáveis de ambiente para o serviço PostgreSQL

É importante definir variáveis de ambiente para configurar os serviços que possam utilizar de dados sensíveis como as senhas do PostgreSQL e do PgAdmin. Para fazer isso, vamos criar uma pasta chamada `config` ao lado do nosso arquivo `docker-compose.yml`.

```bash
$ mkdir config
```

Agora dentro da pasta `config`vamos criar o arquivo `.env.dev` com as variáveis de ambiente. Abra o arquivo `.env.dev` e adicione as seguintes variáveis:

```env
POSTGRES_USER=dukescode
POSTGRES_PASSWORD=1234567890
POSTGRES_DB=dukescode
PGADMIN_DEFAULT_EMAIL=admin@dukescode.com
PGADMIN_DEFAULT_PASSWORD=dukescode
```

> **DICA**: Lembre-se de sempre utilizar senhas fortes mesmo para ambientes de desenvolvimento.

Agora para utilizamos as variáveis de ambiente definidas durante a criaçãos dos serviços basta executar o seguinte comando:

```bash
$ docker compose --env-file ./config/.env.dev up -d
```

### 6. Persistência de dados usando volumes Docker

Para garantir a persistência dos dados do PostgreSQL, definimos o `volume pgdata` no arquivo `docker-compose.yml`. Este `volume` esta criando um mapeamento entre a pasta `/var/lib/postgresql/data` do container com a pasta `/home/dukefs/docker-volumes/postgresql/dev/data` do host.

Dessa forma, todos os dados do PostgreSQL são salvos na máquina host onde podemos definir nossa política de backup, esse mapeamento também garante que os dados serão mantidos mesmo que o container seja reiniciado ou removido.

### 7. Exposição do serviço PostgreSQL para outras aplicações

Por padrão, o serviço PostgreSQL é executado na `porta 5432`. Para acessar o banco de dados a partir de outras aplicações, é necessário expor essa porta. Fizemos isso ao adicionar a seguinte linha ao arquivo `docker-compose.yml`:

```yaml
  .
  .
  .
  ports:
    - '15432:5432'
  .
  .
  .
```

Esta linha expõe a `porta 5432` do container PostgreSQL para a `porta 15432` da máquina host.

### 8. Teste da configuração do PostgreSQL com Docker Compose

Para testar se o serviço PostgreSQL está funcionando corretamente, abra o navegador e acesse a url do PgAdmin em `http://localhost:5050`.

Você verá a tela a seguir.

![pgadmin-home](/img/how-to-run-postgresql-inside-docker-with-compose-and-persistent-data/pgadmin-home.png 'Home do PgAdmin')

_imagem 1 - home do pgadmin_

Agora vamos selecionar _**Add New Server**_ e preencher o **Name** da connection na aba **General**.

![pgadmin-connection-name](/img/how-to-run-postgresql-inside-docker-with-compose-and-persistent-data/pgadmin-connection-name.png 'Nome da conexão')

_imagem 2 - nome da conexão_

Em seguida vamos selecionar a aba **Connection** e preencher as informações de conexão conforme informado no arquivo `.env.dev` e clicar em **Save**.

![pgadmin-connection-details](/img/how-to-run-postgresql-inside-docker-with-compose-and-persistent-data/pgadmin-connection-details.png 'Detalhes da conexão')

_imagem 3 - detalhes da conexão_

Ao preencher todas as informações corretamente, você tera acesso aos dados de estatísticas do servidor PostgreSQL conforme a seguir.

![pgadmin-server-statistics](/img/how-to-run-postgresql-inside-docker-with-compose-and-persistent-data/pgadmin-server-statistics.png 'Estatísticas do Servidor PostgreSQL')

_imagem 4 - estatísticas do servidor postgresql_

### Conclusão e possíveis próximos passos

Neste artigo, aprendemos como configurar o PostgreSQL com persistência de dados usando Docker Compose. Com a configuração correta do arquivo `docker-compose.yml`, podemos criar um ambiente PostgreSQL completo com persistência de dados em questão de minutos. A partir daqui, é possível explorar recursos adicionais do PostgreSQL, como backups, replicação, segurança avançada, entre outros.

Para finalizar, é importante ressaltar que a configuração de um ambiente de produção seguro e escalável envolve muitos outros fatores além do que foi abordado neste artigo. Recomendamos que você aprofunde seus conhecimentos em Docker e PostgreSQL antes de utilizar em ambientes de produção.

---

E é isso por hoje, pessoal!

Chegamos ao final de mais um artigo, espero que tenha sido útil e que você tenha aprendido algo novo.

Caso tenha alguma dúvida, comentário ou tenha encontrado algum erro, por favor, envie-me um [email](mailto:true.dukescode@gmail.com). Ficarei feliz em ouvir de você.

Se desejar receber novos artigos diretamente em seu e-mail, por favor, assine a nossa Newsletter. E se você já é um assinante, muito obrigado!

Aproveito e deixo um convite para nos conectarmos no [Twitter](https://twitter.com/dukefullstack) e [LinkedIn](https://www.linkedin.com/in/dukefullstack/).

👋 Obrigado por ler até o final e até o próximo artigo !!!


Neste artigo, vamos explorar como usar o Docker Compose para configurar um ambiente completo do PostgreSQL com persistência de dados em poucos passos. Este guia é destinado a pessoas que já possuem alguma experiência com o Docker e o PostgreSQL.

Como executar o PostgreSQL no Docker com Docker Compose e persistência de dados

2. Instalação do Docker e Docker Compose

3. Configuração do arquivo docker-compose.yml

4. Criação dos serviços PostgreSQL e PgAdmin com Docker Compose

5. Configuração de variáveis de ambiente para o serviço PostgreSQL

6. Persistência de dados usando volumes Docker

7. Exposição do serviço PostgreSQL para outras aplicações

8. Teste da configuração do PostgreSQL com Docker Compose

Conclusão e possíveis próximos passos


### 1. Introdução

O Docker simplifica o processo de gerenciamento de processos de aplicação em containers. Embora os containers sejam semelhantes às máquinas virtuais de certas maneiras, eles são mais leves em recursos. Isso permite que os desenvolvedores dividam um ambiente de aplicação em vários serviços isolados.

Para aplicações que dependem de vários serviços, orquestrar todos os containers para inicializar, se comunicar e desligar juntos pode rapidamente se tornar complicado. O Docker Compose é uma ferramenta que permite executar ambientes de aplicação multi-container com base em definições definidas em um arquivo YAML. Ele usa definições de serviço para construir ambientes totalmente personalizáveis com vários containers que podem compartilhar redes e volumes de dados.

Neste guia, vamos juntos instalar o Docker em conjunto com Docker Compose em um servidor Ubuntu 22.04.

### 2. Pré-requisitos

Pode parecer bastante óbvio, e é por sinal. Nosso único pré-requisito é uma máquina local ou remota que contenha o Ubuntu 22.04 com um usuário **non-root** com acesso ao `sudo`.

Dito isso vamos a instalação do Docker.

### 3. Instalando o Docker

O pacote de instalação do Docker disponível no repositório oficial do Ubuntu pode não ser a versão mais recente.

Para garantir nosso acesso a versão mais recente, instalaremos o Docker a partir do repositório oficial do Docker.

Para isso, adicionaremos uma nova fonte de pacotes à nossa lista de fontes do `apt`, adicionaremos a chave GPG do Docker para garantir que os downloads sejam válidos e, em seguida, instalaremos o pacote.

Primeiro, vamos atualizar a lista de pacotes do repositório do Ubuntu:

```bash
$ sudo apt update
```

Em seguida, instale alguns pacotes pré-requisitos que permitem que o `apt` use pacotes por `HTTPS`:

```bash
$ sudo apt install apt-transport-https ca-certificates curl software-properties-common
```

Então, adicione a chave GPG para o repositório oficial do Docker em seu sistema:

```bash
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
```

Adicione o repositório do Docker às fontes do APT:

```bash
$ echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
```

Atualize sua lista existente de pacotes novamente para que a inclusão seja reconhecida:

```bash
$ sudo apt update
```

Vamos nos certificar de que iremos a instalar a partir do repositório Docker em vez do repositório padrão do Ubuntu:

```bash
$ apt-cache policy docker-ce
```

Você visualizará uma saída similar a esta, mas é possível que o número da versão do Docker seja diferente.

```bash
docker-ce:
  Installed: (none)
  Candidate: 5:23.0.1-1~ubuntu.22.04~jammy
  Version table:
     5:23.0.0-1~ubuntu.22.05~jammy 500
        500 https://download.docker.com/linux/ubuntu jammy/stable amd64 Packages
     5:20.10.23~3-0~ubuntu-jammy 500
        500 https://download.docker.com/linux/ubuntu jammy/stable amd64 Packages
```

Perceba que o docker-ce não está instalado, mas o pacote candidato para instalação vem do repositório Docker para o **Ubuntu 22.04 (jammy)**.

Por último, realize a instalação do Docker:

```bash
$ sudo apt install docker-ce
```

Após a instalação do Docker, o daemon foi iniciado e o processo habilitado para iniciar automaticamente com o sistema. Para verificar se ele está em execução, execute o comando a seguir:

```bash
$ sudo systemctl status docker
```

A saída deverá ser similar à seguinte, indicando que o serviço está ativo e em execução:

```bash
Output
● docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
     Active: active (running) since Fri 2023-03-08 19:18:31 UTC; 40s ago
TriggeredBy: ● docker.socket
       Docs: https://docs.docker.com
   Main PID: 780 (dockerd)
      Tasks: 71
     Memory: 77.2M
        CPU: 340ms
     CGroup: /system.slice/docker.service
             └─7854 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
```

Ao final da instalaçaão do Docker, além do serviço Docker (daemon), também teremos acesso ao cli do `docker`. Isso significa que podemos gerenciar imagens, contêineres e outros recursos do Docker usando a interface de linha de comando, porém restrita apenas ao usuário root, ou por meio de um usuário com acesso ao `sudo`.

#### 3.1. Executando o docker sem precisar de acesso sudo

Por padrão, o comando `docker` só pode ser executado pelo usuário root ou por um usuário no `grupo docker`, que é automaticamente criado durante o processo de instalação do Docker. Se você tentar executar o comando `docker` sem prefixá-lo com `sudo` ou sem estar no `grupo docker`, veremos um erro semelhante a este:

```bash
docker: Cannot connect to the Docker daemon. Is the docker daemon running on this host?.
See 'docker run --help'.
```

Para resolvermos esse problema e não precisar do `sudo` vamos adicionar nosso usuário ao grupo docker:

```bash
$ sudo usermod -aG docker ${USER}
```

Para aplicar a inscrição ao grupo, digite o seguinte comando:

```bash
$ su - ${USER}
```

Vai ser solicitado que você digite a senha para o seu usuário para continuar.

Após inserir a senha corretamente vamos verificar se agora fazemos parte do grupo de usuários `docker` com o seguinte comando:

```bash
$ groups
```

Veremos algo semelhante:

```bash
dukefs sudo lxd docker
```

Se você precisar adicionar um usuário ao grupo docker com o qual você não está conectado, declare explicitamente o nome de usuário usando:

```bash
$ sudo usermod -aG docker nome_do_usuario
```

Excelente, chegamos ao final da etapa de instalação do Docker. Com isso podemos executar o `docker`sem necessidade do `sudo`:

```bash
$ docker ps
```

Teremos com este comando a seguinte saída:

```bash
CONTAINER ID   IMAGE                           COMMAND        CREATED        STATUS        PORTS
```

Vamos seguir adiante e realizar a instalação do Docker Compose.

### 4. Instalando o Docker Compose

Para obter a versão mais estável e atualizada do Docker Compose, é importante que você acesse o [repositório no Github](https://github.com/docker/compose) e verifique qual é a versão mais recente disponível na [página de releases](https://github.com/docker/compose/releases).

Vale ressaltar que o Docker Compose é uma ferramenta que permite definir e executar aplicativos Docker de vários contêineres, de forma que eles possam ser executados de maneira coordenada e facilmente gerenciados.

No momento em que este texto foi escrito, a versão mais atual e estável do Docker Compose é a 2.16.0. Para baixá-la, basta utilizar o seguinte comando:

```bash
$ mkdir -p ~/.docker/cli-plugins/
$ curl -SL https://github.com/docker/compose/releases/download/v2.16.0/docker-compose-linux-x86_64 -o ~/.docker/cli-plugins/docker-compose
```

Em seguida, vamos defir as permissões corretas para que o comando do `docker compose` possa ser executado:

```bash
$ chmod +x ~/.docker/cli-plugins/docker-compose
```

Para verificar se a instalação foi concluída com êxito, podemos executar o comando abaixo:

```bash
$ docker compose version
```

Iremos obter uma saída similar a esta, mas é possível que o número da versão do Docker Compose seja diferente.

```bash
Docker Compose version v2.16.0
```

Com isso finalizamos a instalação do Docker Compose.

### Conclusão

Chegando ao final de mais um artigo, podemos concluir que o Docker é uma ferramenta importante no gerenciamento de processos de aplicação em containers, e o Docker Compose facilita a orquestração de ambientes de aplicação multi-container com base em definições definidas em um arquivo YAML.

Este guia apresentou um passo a passo para instalar o Docker e o Docker Compose em um servidor Ubuntu 22.04, destacando os pré-requisitos necessários e mostrando como instalar o Docker a partir do repositório oficial do Docker.

Com estas ferramentas, nós desenvolvedores poderemos gerenciar nossos ambientes de desenvolvimento com mais eficiência.

---

E é isso por hoje, pessoal!

Chegamos ao final de mais um artigo, espero que tenha sido útil e que você tenha aprendido algo novo.

Caso tenha alguma dúvida, comentário ou tenha encontrado algum erro, por favor, envie-me um [email](mailto:true.dukescode@gmail.com). Ficarei feliz em ouvir de você.

Se desejar receber novos artigos diretamente em seu e-mail, por favor, assine a nossa Newsletter. E se você já é um assinante, muito obrigado!

Aproveito e deixo um convite para nos conectarmos no [Twitter](https://twitter.com/dukefullstack) e [LinkedIn](https://www.linkedin.com/in/dukefullstack/).

👋 Obrigado por ler até o final e até o próximo artigo !!!


Neste tutorial, iremos juntos realizar a instalação do Docker e Docker Compose no Ubuntu 22.04. Com estas ferramentas seremos capazes de criar ambientes para realizar nossos testes localmente.

Como instalar o Docker e Docker Compose no Ubuntu 22.04

3. Instalando o Docker

3.1. Executando o docker sem precisar de acesso sudo

4. Instalando o Docker Compose

Neste tutorial, irei mostrar a você como fazer o upload e download de arquivos utilizando o banco de dados PostgreSQL como forma de armazenamento. Faremos uso da API Rest do Spring Boot, além de utilizarmos a interface Spring Web MultipartFile para lidar com requisições HTTP  multi-part de forma eficiente.

Criando uma API Rest para upload e download de arquivos com Spring Boot + Armazenamento em banco de dados com PostgreSQL

2. Tecnologias e Estrutura do Projeto

3. Desenvolvimento do Projeto

3.1. Criando a Entity

3.2. Configurando o JPA, Hibernate e os limites de upload e tamanho de arquivos

3.3. Implementando a camada de acesso ao Banco de Dados

3.4. Implementando a camada de Serviço para gerenciar os arquivos

3.5. Implementando as Classes de Resposta para a camada de Controller nossa API

3.6. Criando a camada do Controller para atender as requisições HTTP

3.7. Tratamento adequado das Exceptions

4. Rodando e testando o serviço


Desde que lançaram o ChatGPT, tenho visto muito debate na internet sobre o que tudo isso significa para o futuro do desenvolvimento de software.

Embora haja muitas teorias da conspiração sendo espalhadas, acredito que sobreviveremos e, talvez, nos deparemos com alguma dessas realidades no futuro:

1.  O desenvolvimento de software continuará sendo lucrativo, e nós nos adaptaremos usando ferramentas como o ChatGPT e o Copilot.
2.  Ferramentas como o ChatGPT e o Copilot são apenas o começo do que está por vir, e o futuro do desenvolvimento de software será cada vez mais incerto.

Na minha humilde opinião, ambas essas possibilidades são possíveis e não precisam ser mutuamente exclusivas. No entanto, esse papo mais cabeça não é o foco deste post.

Atualmente, nós desenvolvedores de software podemos nos beneficiar dessas ferramentas, o que, na minha opinião, devemos abraçar em vez de evitar.

Neste post, quero destacar 3 casos de uso do ChatGPT que me ajudam e podem ajudar você também. Em particular, eles são: Explicação de código, a identificação de bugs e a geração automática de código.

### 1. Explicação de Código

Vamos dizer, então, que eu ou você pegamos um novo projeto com uma base de código existente e estamos tentando entender como tudo está organizado, o que os desenvolvedores anteriores escreveram e como tudo funciona.

Isso pode ser bastante desafiador. Embora o ChatGPT não possa explicar todo o código de uma vez, ele pode nos ajudar a entender seções ou segmentos específicos.

Por exemplo, eu pedi ao ChatGPT para explicar o seguinte trecho de código.

```python
def do_POST(self):
	content_length = int(self.headers["Content-Length"])
	body = self.rfile.read(content_length)
	data = json.loads(body.decode())
	param = data["paran"]
	device = "cuda" if torch.cuda.is_available() else "cpu"
	model = whisper.load_model("base").to(device)
	result = model.transcribe("/upload/"+ paran + ".mp3", fp16=False)
	message = {"message": result["segments"]}

	self._send_response(message)

```

Veja a resposta do ChatGPT.

_O trecho de código apresentado é uma definição de método em Python que lida com solicitações HTTP POST. O método utiliza a classe self para acessar os dados da solicitação._

_Primeiramente, o código lê o comprimento do conteúdo da solicitação HTTP na variável `content_length`. Em seguida, o corpo da solicitação é lido da conexão de entrada usando a função `read()` e armazenado na variável `body`._

Em seguida, o conteúdo do corpo da solicitação é carregado em um objeto JSON por meio da função `json.loads()`. O valor do parâmetro JSON `paran` é atribuído à variável `param`.\_

_A variável `device` recebe o valor "cuda" se o PyTorch detectar uma GPU disponível, caso contrário, a variável recebe o valor "cpu"._

_O código carrega um modelo de reconhecimento de fala usando a biblioteca Whisper, definindo o dispositivo de processamento a ser usado com base na variável `device`. O modelo é carregado a partir do arquivo "base"._

_Finalmente, o modelo é usado para transcrever um arquivo de áudio especificado pelo parâmetro `paran`. O resultado da transcrição é armazenado na variável `result`. O resultado é formatado em uma mensagem JSON que contém uma lista de segmentos de fala. A mensagem JSON é enviada como resposta para a solicitação HTTP usando a função `_send_response()`._

Após receber a resposta inicial que me deu uma ideia do que a função fazia, percebi que era necessário fazer algumas correções no código.

Decidi, então, pedir ajuda ao ChatGPT para realizar o debugging.

### 2. Identificação de Bugs ou Debugging

Na minha opinião, esse é o uso mais catalisador para aumentar a produtividade quando se trata de desenvolvimento e debugging. É como se estivéssemos fazendo pair programming para resolver um problema.

No entanto, se eu simplesmente perguntar ao ChatGPT qual é o problema com o código acima, ele me daria conselhos muito genéricos. Por isso, é essencial ser o mais específico possível.

Por exemplo, este foi o prompt que utilizei:

**Prompt:** _Durante a execução da funcão o whisper não esta localizando os arquivos no diretório informado; qual poderia ser o problema?_

Veja a resposta que o ChatGPT me deu:

_Há um erro na variável `param`, que é definida como `data["paran"]`, mas deveria ser `data["param"]`. Assim, quando o código tenta encontrar o arquivo de áudio para transcrever, está procurando um arquivo com o nome errado. Para corrigir o problema, basta trocar a linha `param = data["paran"]` para `param = data["param"]`._

Podemos considerar que esse é um ponto de partida promissor! Agora, só precisamos ajustar o nome da nossa variável para que tudo funcione corretamente.

### 3. Geração Automática de Código

O ChatGPT tem a capacidade de gerar código básico, como modelos ou esqueletos, economizando tempo em tarefas repetitivas. Isso pode ser especialmente útil em projetos que envolvem diversas linguagens e bibliotecas diferentes.

Um desenvolvedor pode descrever o que precisa ser feito e o ChatGPT pode gerar o código básico necessário para iniciar o trabalho, o qual pode ser facilmente ajustado às suas próprias especificidades.

A seguir apresento um exemplo básico.

**Prompt:** _Escreva uma simples API Hello World com um metodo get e outro post para alterar a mensagem. Deve receber a nova mensagem pelo body json, para isso utilize FLASK._

E vejamos a resposta do ChatGPT:

```python
from flask import Flask, jsonify, request

app = Flask(__name__)

message = "Hello, World!"

@app.route('/', methods=['GET'])
def get_message():
    return jsonify({'message': message})

@app.route('/', methods=['POST'])
def set_message():
    global message
    message = request.json['message']
    return jsonify({'message': message})

if __name__ == '__main__':
    app.run(debug=True)
```

Embora este seja um exemplo trivial que poderíamos ter encontrado facilmente na pesquisa do Google, a abordagem permanece a mesma para produzir códigos mais complexos.

### Conclusão

Eu acredito que estamos em um momento de transição em que ferramentas de inteligência artificial, como o ChatGPT, podem moldar a forma como os programadores escrevem código no futuro. Vendo o lado positivo, isso significa que podemos passar mais tempo garantindo a qualidade do produto, em vez de nos perdermos em um emaranhado de linhas de código.

Os casos de uso que destaquei neste post são apenas alguns dos mais revolucionários para a nossa área. Na minha opinião, isso é apenas a ponta do iceberg. Por exemplo, outros cenários que me vêm à mente incluem a otimização de código, a escrita de documentação e a aprendizagem de novas tecnologias.

Em resumo, gosto de pensar no ChatGPT como o meu próprio _"assistente pessoal de programação"_, pronto para me ajudar quando preciso.

---

E é isso por hoje, pessoal!

Chegamos ao final de mais um artigo, espero que tenha sido útil e que você tenha aprendido algo novo.

Caso tenha alguma dúvida, comentário ou tenha encontrado algum erro, por favor, envie-me um [email](mailto:true.dukescode@gmail.com). Ficarei feliz em ouvir de você.

Se desejar receber novos artigos diretamente em seu e-mail, por favor, assine a nossa Newsletter. E se você já é um assinante, muito obrigado!

Aproveito e deixo um convite para nos conectarmos no [Twitter](https://twitter.com/dukefullstack) e [LinkedIn](https://www.linkedin.com/in/dukefullstack/).

👋 Obrigado por ler até o final e até o próximo artigo !!!


Neste post, apresentamos três maneiras pelas quais o ChatGPT pode ser útil no processo de desenvolvimento de software, incluindo a explicação de código, a identificação de bugs e a geração automática de código. Aprenda como essas dicas práticas podem ajudar a otimizar e efetivar seu processo de desenvolvimento.

Transforme seu processo de desenvolvimento de software com ChatGPT - 3 dicas práticas para otimização e eficiência

1. Explicação de Código

2. Identificação de Bugs ou Debugging

3. Geração Automática de Código

Turbine a sua caixa de entrada

Junte-se a mais de 0 desenvolvedores inscritos