Posted on Sep 6, 2022 • Atualizado em Oct 12, 2022

Desenvolvimento Local - Internet Computer

#internetcomputer #blockchain #dfinity #web3

Este cenário de Início Rápido pressupõe que você está instalando o SDK pela primeira vez e deseja executar um cânister em um ambiente de execução de cânister local em vez de implantá-lo na blockchain da Internet Computer.

Para começar, vamos construir e implantar um simples cânister de nome “Hello” que tem apenas uma função - de nome greet. A função greet aceita um argumento de texto e retorna o resultado com uma saudação semelhante a “Olá, todos!” em um terminal, se você executar o cânister usando a linha de comandos ou em uma página HTML, se você acessar o cânister em um navegador.

Antes de começar

Antes de baixar e instalar esta versão do SDK, verifique se:

Você tem uma conexão com a Internet e acesso a um shell de terminal em seu computador macOS ou Linux local.

Atualmente, o SDK é executado apenas em computadores com sistema operacional macOS ou Linux.
Você tem o node.js instalado, se quiser incluir os arquivos de modelo padrão para desenvolvimento de front-end em seu projeto.

Baixar e instalar

Você pode baixar a versão mais recente do SDK diretamente de um shell de terminal em seu computador local.

Para baixar e instalar:

Abra um shell de terminal em seu computador local.

Por exemplo, abra Aplicativos, Utilitários e clique duas vezes em Terminal ou pressione ⌘+barra de espaço para abrir o Buscador e digite terminal.
Baixe e instale o pacote SDK executando o seguinte comando:
```
sh -ci "$(curl -fsSL https://smartcontracts.org/install.sh)"
```
Este comando solicita que você leia e aceite o contrato de licença antes de instalar a interface de linha de comando (CLI) de execução DFINITY e suas dependências em seu computador local.
Digite y e pressione Return para continuar com a instalação.

O comando exibe informações sobre os componentes que estão sendo instalados no computador local.

Verifique se o SDK está pronto para uso

Se o script de instalação for executado sem erros, tudo o que você precisa para começar a desenvolver programas executados na IC estará disponível em seu computador local.

Para verificar se o SDK está pronto para uso:

Abra um shell de terminal em seu computador local, se você ainda não tiver um aberto.
Verifique se você tem a interface de linha de comando (CLI) de execução do DFINITY instalada e se o comando executável dfx está disponível em seu PATH executando o seguinte comando:
```
dfx --version
```
O comando exibe informações de versão para o executável de linha de comando dfx. Você pode ver a versão mais recente nas notas de lançamento.
Visualize as informações de uso dos outros subcomandos dfx da linha de comando executando o seguinte comando:
```
dfx --help
```
O comando exibe informações de uso para o comando-pai dfx e seus subcomandos.

Crie um novo projeto

Dapps na Internet Computer começam como projetos. Você cria projetos usando o comando-pai dfx e seus subcomandos.

Para este tutorial, começaremos com o dapp de amostra padrão para ilustrar a criação do dapp usando os arquivos iniciais padrão em um projeto. Quando você cria um novo projeto, a interface de linha de comando dfx adiciona uma estrutura de diretórios de projeto padrão ao seu espaço de trabalho. Cobrimos os arquivos de modelo padrão que compõem um diretório de projeto no tutorial Explorando o projeto padrão.

Para criar um novo projeto para seu primeiro aplicativo:

Abra um shell de terminal em seu computador local, se você ainda não tiver um aberto.
Crie um novo projeto chamado hello executando o seguinte comando:
```
dfx new hello
```
O comando dfx new hello cria um novo diretório de projeto hello, arquivos de modelo padrão e um novo repositório no Git para seu projeto, chamado hello.

Se você usar um nome de projeto diferente em vez de hello, anote o nome usado. Você precisará usar esse nome de projeto no lugar do nome do projeto hello ao longo destas instruções.
Mude para o diretório do seu projeto executando o seguinte comando:
```
cd hello
```

Inicie a implantação local

Antes de construir seu primeiro projeto, você precisa se conectar ao ambiente de execução do cânister local. Como prática recomendada, esta etapa requer que você tenha dois shells de terminal abertos, para que você possa iniciar e ver as operações de execução do cânister em um terminal e gerenciar seu projeto em outro.

Para preparar o ambiente de execução do cânister local:

Abra uma segunda janela de terminal ou guia em seu computador local.
Navegue até o diretório raiz do seu projeto, se necessário.

Agora você deve ter dois terminais abertos com seu diretório de projeto como seu diretório de trabalho atual em ambos os terminais.
Inicie o ambiente de execução do cânister local em seu computador no seu segundo terminal executando o seguinte comando:
```
dfx start
```
Dependendo de sua plataforma e configurações de segurança locais, você poderá ver um aviso exibido. Se você for solicitado a permitir ou negar conexões de rede de entrada, clique em Permitir.
Deixe a janela do terminal que exibe as operações de execução do cânister aberta e mude seu foco para a primeira janela do terminal onde você criou seu novo projeto.

Você executa as etapas restantes no terminal que não exibe as operações de execução do cânister.

Registre, construa e implante o aplicativo

Depois de se conectar ao ambiente de execução do cânister local, você pode registrar, construir e implantar seu dapp localmente.

Para implantar seu primeiro dapp localmente:

Verifique se você ainda está no diretório raiz do seu projeto, se necessário.
Certifique-se de que os módulos node estão disponíveis no diretório do projeto, se necessário, executando o seguinte comando:
```
npm install
```
Para obter mais informações sobre esta etapa, consulte Garantindo que o node esteja disponível em um projeto.

Registre, construa e implante seu primeiro dapp executando o seguinte comando:

dfx deploy

O output do comando dfx deploy exibe informações sobre as operações que ele executa. Por exemplo, esta etapa registra dois identificadores — um para o programa principal hello e outro para a interface de usuário front-end hello_assets — e informações de instalação semelhantes às seguintes:

Creating a wallet canister on the local network.
The wallet canister on the "local" network for user "default" is "rwlgt-iiaaa-aaaaa-aaaaa-cai"
Deploying all canisters.
Creating canisters...
Creating canister "hello"...
"hello" canister created with canister id: "rrkah-fqaaa-aaaaa-aaaaq-cai"
Creating canister "hello_assets"...
"hello_assets" canister created with canister id: "ryjl3-tyaaa-aaaaa-aaaba-cai"
Building canisters...
Building frontend...
Installing canisters...
Creating UI canister on the local network.
The UI canister on the "local" network is "r7inp-6aaaa-aaaaa-aaabq-cai"
Installing code for canister hello, with canister_id rrkah-fqaaa-aaaaa-aaaaq-cai
Installing code for canister hello_assets, with canister_id ryjl3-tyaaa-aaaaa-aaaba-cai
Authorizing our identity (default) to the asset canister...
Uploading assets to asset canister...
/index.html 1/1 (573 bytes)
/index.html (gzip) 1/1 (342 bytes)
/index.js 1/1 (605692 bytes)
/index.js (gzip) 1/1 (143882 bytes)
/main.css 1/1 (484 bytes)
/main.css (gzip) 1/1 (263 bytes)
/sample-asset.txt 1/1 (24 bytes)
/logo.png 1/1 (25397 bytes)
/index.js.map 1/1 (649485 bytes)
/index.js.map (gzip) 1/1 (149014 bytes)
Deployed canisters.

Se você criou um projeto com um nome diferente, no entanto, os nomes dos cânisteres corresponderão ao nome do projeto em vez de hello e hello_assets.

Você também deve observar que na primeira vez que implantar, o dfx cria uma identidade default (padrão) e uma carteira de ciclos (cycle wallet) local controlada por sua identidade default. Uma carteira de ciclos é um tipo especial de cânister que permite transferir ciclos para outros cânisteres.

Para implantar este dapp de amostra localmente, você não precisa saber nada sobre sua identidade de desenvolvedor padrão, usar uma carteira de ciclos ou gerenciar ciclos. Abordaremos esses tópicos mais tarde, mas, por enquanto, observe que eles são criados automaticamente para você.

Chame o cânister hello e a função greet predefinida executando o seguinte comando:
```
dfx canister call hello greet everyone
```
Vamos dar uma olhada mais de perto neste comando de exemplo:

O comando dfx canister call requer que você especifique um nome de cânister e um método—ou função—para chamar.
hello especifica o nome do cânister que você deseja chamar.
greet especifica o nome da função que você deseja chamar no cânister hello.
everyone é o argumento de tipo de dados de texto que você deseja passar para a função greet.

Lembre-se, no entanto, que se você criou um projeto com um nome diferente, o nome do cânister corresponderá ao nome do seu projeto e você precisará modificar a linha de comando para corresponder ao nome usado em vez de hello.

Verifique se o comando exibe o valor de retorno da função greet.

Por exemplo:
```
("Hello, everyone!")
```

Teste o frontend do dapp

Agora que você verificou que seu dapp foi implantado e testou sua operação usando a linha de comando, vamos verificar se você pode acessar o front-end usando seu navegador da web.

Inicie o servidor de desenvolvimento com npm start
Abra um navegador.
Navegue até http://localhost:8080/

Navegar para essa URL exibe uma página HTML simples com um arquivo de imagem de ativo de amostra, um campo de entrada e um botão. Por exemplo:

Digite uma saudação e clique em Click Me! para retornar a saudação.

Por exemplo:

Pare o ambiente de execução do cânister local

Depois de testar o aplicativo no navegador, você pode parar o ambiente de execução do cânister local para que ele não continue sendo executado em segundo plano.

Para interromper a implantação local:

No terminal que exibe o servidor de desenvolvimento, pressione Control-C para interromper o processo do servidor de desenvolvimento.
No terminal que exibe as operações de execução do cânister, pressione Control-C para interromper o processo de rede local.
Pare o ambiente de execução do cânister local em execução em seu computador local executando o seguinte comando:
```
dfx stop
```

Próximos passos

Este Guia de Início Rápido abordou apenas algumas etapas importantes para apresentar o fluxo de trabalho básico para você desenvolver seus próprios dapps. Você pode encontrar exemplos e tutoriais mais detalhados para ajudá-lo a aprender sobre como usar o Motoko e como desenvolver dapps para rodar na blockchain da Internet Computer em toda a documentação.

Aqui estão algumas sugestões para onde ir a seguir:

Construindo na IC - para explorar a construção de dapps simples usando um ambiente de execução de cânister local.
Converta tokens ICP em ciclos - se você tiver tokens ICP que deseja converter em ciclos para permitir que você implante o dapp na blockchain da Internet Computer.
Implantação on-chain - se você tiver ciclos e estiver pronto para implantar um aplicativo na rede principal da blockchain da Internet Computer.
O que é Candid? - para aprender como a linguagem de descrição da interface Candid permite a interoperabilidade e a capacidade de composição de serviços.
Visão geral do Motoko - para aprender sobre os recursos e a sintaxe ao usar o Motoko.

Este guia foi publicado nos Docs do Desenvolvedor da Internet Computer. Tradução por Paulinho Giovannini.

Top comments (0)

Se inscrever

WEB3DEV