Adriano Neres

Configurando um ambiente de desenvolvimento Node.js

2019-08-16T16:00:00+00:00

Os passos para instalação e configuração devem ser executados via linha de comando, utilizando um gerenciador de pacotes.

Se você usa uma distribuição de Linux é provável que já possua um gerenciador de pacotes padrão. Se utiliza Windows ou Mac OSX recomendarei um gerenciador para cada um destes sistemas operacionais.

Para garantir que os passos para instalação dos gerenciadores de pacote permaneçam atualizados deixarei apenas os links para a página contendo o processo de instalação de cada um. Com ele instalado poderemos prosseguir com a configuração do ambiente.

1. Gerenciador de pacotes

Mac OSX

Usuários de Mac OSX podem optar pelo Homebrew. Este é um ótimo gerenciador de pacotes e amplamente utilizado pelos usuários desta plataforma.

O processo de instalação é descrito na própria página inicial do Homebrew.

Windows

Para usuários de Windows recomendo a utilização do Chocolatey.

O processo de instalação é bem simples e pode ser realizado via cmd.exe ou via PowerShell.exe. Para instalá-lo, execute os passos descritos na página de instalação do Chocolatey.

2. NVM

Você poderia pular esta etapa e instalar uma versão do Node.js diretamente. No entanto, recomendo que instale primeiro o NVM e, por meio dele, configure as versões de Node.js que precisar.

Mas, afinal, o que é e para que serve o NVM?

O NVM (Node Version Manager) é um gerenciador de versões do Node.js.

Ele é útil quando precisamos ter várias versões diferentes no Node.js instaladas em nossa máquina.

E por que eu precisaria de mais de uma versão do Node.js instalada na minha máquina?

Se você trabalha com vários projetos que utilizam Node.js, pode ser que a versão necessária para cada um deles seja diferente. Nesse caso, o NVM vai te ajudar a controlar qual versão será utilizada em cada momento.

E como eu instalo o NVM?

Isso depende do Sistema Operacional e do gerenciador de pacotes utilizado:

Linux via curl:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.34.0/install.sh | bash

Mac OSX via Homebrew:

brew install nvm

Windows via Chocolatey:

choco install nvm

Após a instalação recomendo reiniciar o terminal para garantir que as configurações do NVM sejam carregadas.

3. Node.js

Com o NVM instalado basta executar o comando a seguir para instalar a última versão estável.

Se você utiliza Windows:

nvm install latest

Se utiliza Linux ou Mac OSX:

nvm install node --lts

E para selecioná-la como versão padrão:

nvm use --lts

Para verificar se o Node.js foi instalado e configurado corretamente:

node -v

A saída do comando anterior deve ser a versão instalada em sua máquina.

4. Yarn

A instalação do Yarn é opcional. Particularmente, eu gosto de utilizá-lo, mas fica a seu critério (ou à de seu time).

Mas, afinal, o que é e pra que serve o Yarn?

O Yarn é um gerenciador de dependências. É uma opção ao gerenciador padrão do Node.js - o npm.

Ele te possibilitará, entre outras coisas, instalar, desinstalar e configurar as dependências do seu projeto.

E como eu instalo o Yarn?

Isso também depende do Sistema Operacional utilizado.

Felizmente o Yarn disponibiliza uma página onde encontramos o processo de instalação descrito com detalhes.

Para instalá-lo, visite a página de instalação do Yarn, seleciona o Sistema Operacional e siga o processo referente ao gerenciador de pacotes que você utiliza.

Configurando Gogs com MySQL no Docker

2018-02-28T12:53:10+00:00

Algumas vezes, principalmente em ambientes corporativos, pode ser necessário configurar um servidor Git. O Gogs é um ótima alternativa para isso.

Criaremos um compose file utilizando as imagens do MySQL e do Gogs. Por isso é interessante baixa-las do Docker Hub para seu repositório local, caso ainda não tenha feito:

  docker pull mysql:5.7
  docker pull gogs/gogs

Compose file

Crie o arquivo docker-compose.yml e adicione o conteúdo:

  version: '3'
  services:
    gogs:
      image: gogs/gogs
      container_name: gogs
      restart: always
      ports:
        - "10022:22"
        - "10080:3000"
      networks:
        - gogs-network
      volumes:
        - "/var/gogs/gogs-volume:/data"
      depends_on:
        - "mysql"
    mysql:
      image: mysql:5.7
      container_name: mysql
      restart: always
      environment:
        MYSQL_ROOT_PASSWORD: "root"
        MYSQL_DATABASE: "gogs"
      networks: 
        - "gogs-network"
      volumes:
        - "/var/gogs/mysql-volume:/var/lib/mysql"
  networks:
    gogs-network:
      driver: "bridge"

No diretório onde o arquivo foi criado execute o comando:

  docker-compose up -d

Acesse a interface de configuração do Gogs pelo navegador, acessando a url http://localhost:10080 e prossiga com as configurações iniciais da ferramenta.

Primeiro acesso ao Gogs e configuração inicial pela interface

Ao acessar pela primeira vez a interface do Gogs pela interface disponível em http://localhost:10080, será possível visualizar um formulário para efetuar a configuração inicial da ferramenta. Alguns valores podem ser um pouco confusos ao efetuar essa configuração então segue um guia de como fazê-los baseado na configuração de nossos containers:

Repository root path: Deixe o valor padrão (/home/git/gogs-repositories), pois o script de inicialização do Gogs (start.sh) possui um link simbólico para este diretório. É claro que é possível alterar depois pelo arquivo de configuração, mas inicialmente é preferível inicia-lo assim.
Run user: Deixe o valor padrão aqui também, pois o script build.sh já possui um apontamento para o usuário git.
Domain: Informe o IP do Docker host, ou o DNS deste host na rede, para que seja possível acessar o Gogs pela rede.
SSH Port: Informe a porta do Docker Host para qual a porta 22 do container foi mapeada. No nosso caso será a porta 10022.
HTTP Port: Ao contrário da configuração anterior, a porta a ser informada aqui não é a correspondente no Docker Host, mas sim a do próprio container. No nosso caso deixaremos a porta 3000.
Application URL: Esta é uma combinação do Domain e da porta HTTP, desta vez a do prório Docker Host. No nosso caso será http://{IP}:10080, substituindo {IP} pelo IP do Docker Host.

Entendendo o compose file

Apesar da análise não estar na ordem em que as configurações foram escritas, preferi faze-la desta forma para facilitar o entendimento.

Configurando a rede

Primeiramente é necessário garantir que os containers estejam na mesma rede. Isso porque em cada execução o docker vincula um IP diferente ao container iniciado. Por esse motivo a comunicação entre eles deverá ser feita pelos nomes de cada um e não diretamente pelo IP. O fato é que não é possível fazer este vínculo por nome utilizando a rede padrão.

Para resolver isso, então, na sessão networks definimos uma rede, a qual damos o nome de gogs-network e que será vinculada tanto ao container do Gogs quanto ao do MySQL.

Configurando o MySQL

Na sessão mysql fazemos a configuração do banco de dados que armazenará os dados de configuração do Gogs. Em image definimos a imagem e versão (mysql:5.7) e em container_name damos um nome para o container referente ao MySQL que será criado quando executarmos o compose file. Este nome é importante porque será por ele, e não pelo IP, que faremos o vínculo da base de dados com o Gogs.

Em seguida, em restart, definimos o comportamento do MySQL ao executarmos este arquivo e então chegamos nas configurações sensíveis da base de dados.

Em environment configuramos as variáveis de ambiente do MySQL. As duas variáveis utilizadas no script são variáveis definidas pela própria imagem do MySQL e que, quando vinculadas, refletem na configuração da base de dados. MYSQL_ROOT_PASSWORD é a variável que define a senha do usuário root do MySQL e MYSQL_DATABASE é a variável que define o nome do schema que será criado ao inicializar o container.

Em networks vinculamos a rede que definimos anteriormente.

E em volumes definimos um volume, onde os dados serão escritos no Docker Host. Neste caso eles serão escritos no diretório /var/gogs/mysql-volume no Docker Host.

Configurando o Gogs

Na sessão gogs é onde faremos a configuração do nosso servidor Git. Assim como na configuração do MySQL apontamos a imagem, damos um nome ao container que será criado na execução do compose file e definimos o comportamento do serviço para reiniciar automaticamente caso ele pare ou aconteça algum erro durante sua execução.

Em ports definimos as portas que serão vinculadas à suas correspondentes no container. Neste caso vinculamos as portas 10022 e 10080 do Docker Host às portas 22 e 3000 do container, respectivamente. Nesta ordem, também, elas representam as portas que responderão às chamadas SSH e HTTP, possibilitando o acesso aos repositórios por meio destes protocolos.

Em networks, assim como fizemos na configuração do MySQL, vinculamos a rede que criamos, de forma que, estando ambos na mesma rede, garantimos que será possível realizar a comunicação entre eles.

Em volumes configuramos o diretório onde os arquivos do Gogs, inclusive os próprios códigos-fontes dos projetos que enviarmos para este servidor, serão escritos. Neste caso eles serão escritos em /var/gogs/gogs-volume.

E, finalmente, em depends_on vinculamos o valor mysql. Precisamos desta configuração para garantir que o container do Gogs, ao executarmos o compose file, seja iniciado somente quando o container do MySQL estiver disponível, evitando assim possíveis problemas na tentativa de tentar acessar a base de dados “antes da hora”.