Como configurar um ambiente Solana do zero usando Anchor no Windows e Linux
Tags: rust, anchor, solana, blockchain
Published: 2021-11-24 21:28:36

Se você tem interesse em começar a desenvolver na blockchain Solana porém não tem ideia de por onde começar esse é o tutorial certo para você. Vamos configurar um ambiente Solana do absoluto zero até conseguirmos rodar nosso projeto com Anchor.

## 👩‍💻 Instalando o WSL

Tecnicamente não vamos usar o Windows nesse tutorial, ao invés disso vamos usar o WSL (Windows Subsystem for Linux).

Pra começar a usar o WSL nós vamos precisar instalar ele. Podemos fazer isso abrindo o CMD.exe como administrador e rodando este comando:

> É recomendável que você instale todas as atualizações do Windows update antes de dar início a instalação do WSL.

```
wsl --install
```

Esse comando vai habilitar componentes opcionais, instalar o último kernel do Linux, atribuir WSL 2 como seu subsistema padrão e instalar uma distribuição Linux para você (por padrão é o Ubuntu)

Caso você esteja interessado em fazer algo um pouco mais do seu jeito, sinta-se livre para consultar este [guia de instalação do WSL](https://www.windowscentral.com/install-windows-subsystem-linux-windows-10) (em inglês)

Vá ate a sua barra de tarefas e procure pelo WSL. Clique nele e espere um terminal aparecer. Caso apareça algum erro tente seguir os passos abaixo:

- Verificar se o Subsistema Linux está habilitado no Windows

Nós precisamos ter certeza que permitimos o WSL no Windows. Vá até a barra de pesquisa e procure por "Ativar ou desativar recursos do Windows" ou "Windows Features". Ao clicar nele você deve ver uma série de funcionalidades do WIndows, procure e ative as seguintes funções:

Windows Subsystem for Linux
Virtual Machine Platform

Reinicie sua máquina e veja se você consegue abrir o terminal WSL normalmente. Se algum erro ainda persistir talvez a virtualização da sua CPU não esteja ativada.

- Habilite a virtualização.

Normalmente essa funcionalidade não está ativada na sua CPU. Para ter certeza de que a virtualização está habilitada no seu computador nós vamos precisar acessar a BIOS. Os computadores tem diferentes formas de se entrar na BIOS. Eu recomendo que procure pelo modelo do seu computador/BIOS e como ter acesso a ele no Google.
Para acessarmos a BIOS do nosso computador vamos precisar reiniciar ele.

Assim que seu computador estiver ligando e mostrando as primeiras telas de inicialização aperte "DEL" ou "F2" no teclado. Normalmente uma dessas teclas funciona. Depois de entrar na BIOS do computador procure pela seção de "Advanced options" (o nome pode estar diferente na sua BIOS). Vá até a parte de CPU ou virtualização e assegure que as opções estão habilitadas.

Uma vez que a instalação foi feita você **PRECISA** reiniciar seu computador para que as alterações tenham efeito.

## 📀 Instalando o NPM

Ótimo! Agora você tem o subsistema Linux disponível na sua máquina
Uma coisa que você já deve ter percebido é que o nosso ambiente é uma abstração do ambiente Windows. Então, tudo que está instalado na nossa máquina Windows não está disponível no nosso Linux. Isso significa que teremos que baixar algumas ferramentas dentro do subsistema para começar o nosso desenvolvimento.

Para fazer o download do NPM nós vamos precisar do cURl. O cURL é um utilitário de linha de comando utilizado para transferência de dados com método HTTP.

```
$ sudo apt-get install curl
```

Agora utilize o curl para baixar o NVM (Node version manager).
```
$ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.38.0/install.sh | bash
```

Reinicie o terminal do WSL

Vamos ver se a instalação foi feita êxito, rode o seguinte comando:
```
$ command -v nvm
```
Se a saída for "nvm" é porque a instalação foi feita corretamente.

Utilize o nvm para instalar a versão estável mais recente do Node.

```
$ nvm install --lts
```

E é isso. Não é simples utilizar o nvm?

Se quiser ter a certeza que a instalação foi feita rode:

````
$ node -v
```

## 🦀 Instalando o Rust

Em Solana, os programas são escritos em Rust! Vamos instala-lo

```
$ curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
```

Quando a instalação terminar rode:

```
rustup --version
```

Verifique a presença do compilador Rust.

```
rustc --version
```

Cargo é o gerenciador de pacotes do Rust. Veja se ele foi instalando junto com os outros pacotes:

```
cargo --version
```

Se você recebeu a saída de versão de todos os pacotes isso significa que tudo correu bem.

## ☀️ Instalando a Solana

A Solana possui um CLI (command-line interface) que nos ajuda a construir e testar os programas que nós escrevemos.

Instale a versão estável da Solana-cli.

```
$ sh -c "$(curl -sSfL https://release.solana.com/stable/install)"
```

Verifique se não tem nenhum erro no retorno do comando e a versão da solana-cli.

```
$ solana --version
```

Se a saída for o número da versão então você conseguiu instalar a Solana.

A próxima coisa que você vai querer fazer é definir o localhost como seu ambiente de desenvolvimento.

Rode esses dois comandos separadamente:

```
$ solana config set --url localhost
$ solana config get
```

A saída será parecido com isso:

```
Config File: /Users/jeronimo/.config/solana/cli/config.yml
RPC URL: http://localhost:8899
WebSocket URL: ws://localhost:8900/ (computed)
Keypair Path: /Users/jeronimo/.config/solana/id.json
Commitment: confirmed
```
Isso significa que a Solana está funcionando e consegue se comunicar com a nossa rede local. Quando você desenvolver um programa na blockchain, estará trabalhando na sua rede local e assim poderá testar rapidamente as coisas.

A última coisa que você precisa testar é se os validadores da Solana estão rodando. Rode este comando:

```
$ solana-test-validator
```

Pode demorar um pouco para iniciar. Se você ver algo parecido com essa imagem abaixo é porque os validadores estão funcionando como deveriam.

![Terminal do WSL mostra os validadores rodando pós-execução do comando](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qols0r6dmmt2fc80k44j.png)

## ☕️ Instalando o Mocha

Mocha é um framework Javascript que vai te ajudar a testar seus contratos construidos na Solana.

```
$ npm install -g mocha
```
É isso. Simples assim!

## ⚓️ Instalando e configurando o Anchor

Se você conhece um pouco de outros ambientes como o Ethereum você provavelmente conhece ambientes de desenvolvimento como o Hardhat. O Anchor é o ambiente de desenvolvimento da Solana, facilitando a compilação, o deploy, teste e debug dos contratos.

O Anchor é um projeto que ainda está no início. Se você tiver algum problema durante a instalação ou a utilização do framework entre no Discord dos desenvolvedores e se sinta livre para perguntar algo ou abrir uma issue no github deles.

Para instalar o Anchor execute estes comandos: 
```
$ npm install --global yarn
$ sudo apt-get update && sudo apt-get upgrade && sudo apt-get install -y pkg-config build-essential libudev-dev libssl-dev
$ cargo install --git https://github.com/project-serum/anchor anchor-cli --locked
```
Rode o comando de consulta de versão do Anchor e veja se deu tudo certo.

```
anchor --version
```

## 🏃‍♂️ Crie seu primeiro projeto e teste-o

Estamos pertos de terminar a configuração do ambiente (aguente firme!). A última coisa que precisamos fazer é rodar um programa na Solana para termos a certeza de que tudo está funcionando.

Vamos criar o nosso primeiro projeto.

```
$ anchor init testproject --javascript
$ cd testproject
```
O `anchor init` vai criar uma série de arquivos/diretórios para nós. Funciona como um create-react-app.

Gere sua conta Solana local. Vamos precisar dele daqui a pouco.

```
$ solana-keygen new
```

Agora vamos ao momento que estavamos esperando. Rode os testes!

```
$ anchor test
```

Isso pode demorar um pouco na primeira vez que você roda-lo. Se você ver um texto verde que diz "1 passing" na parte debaixo do seu console significa que está tudo funcionando perfeitamente!

- - -
## ✨ Considerações finais
🥳 Parabéns! Você conseguiu, você configurou seu ambiente Solana e agora está pronto para mergulhar de cabeça no mundo dos aplicativos descentralizados.

Todo esse artigo é uma tradução de um tutorial já existente da buildspace. [Acesse ele aqui](https://github.com/buildspace/buildspace-projects/blob/main/Solana_And_Web3/en/Section_2/Resources/windows_setup.md)

O buildspace é o lugar perfeito para você aprender a desenvolver para a blockchain de graça e com o apoio da comunidade dev.

[Clique aqui](https://app.buildspace.so/home) para acessar o site deles e ver os cursos disponíveis.

Se você achou algum erro, tem uma sugestão para melhorar este tutorial, tem uma dúvida ou simplesmente só quer falar comigo você pode chegar até mim pelo [Twitter](https://twitter.com/HereJers).