O que é Lando?

Lando será seu assistente no desenvolvimento, execução e automação do seu projeto. Pense nisso como uma camada de abstração do seu ambiente de desenvolvimento que é padronizada em todos os principais sistemas operacionais, como MacOS, Windows e Linux. Vale ressaltar que o uso do Lando na produção não é incentivado ou apoiado pela equipe Lando, já que seu principal objetivo é imitar o ambiente de produção localmente.

Usando o Lando, qualquer desenvolvedor pode configurar as configurações na base de código para os serviços, ferramentas e configurações que o aplicativo precisa executar. Uma vez que isso é configurado, tudo o que os membros da equipe precisam fazer é puxar o repositório e executar e começar a trabalhar no projeto em um ambiente de desenvolvimento isolado sem se preocupar com inconsistências em seus ambientes de desenvolvimento.lando start

Como funciona o Lando e por que devemos usá-lo?

Agora, você deve ter percebido que o que descrevemos acima tem muitas semelhanças com o Docker e seus serviços relacionados. Você provavelmente se perguntou:

  • As configurações de configuração do Lando que eles estão falando são realmente semelhantes ao , certo?docker compose
  • O ambiente de desenvolvimento isolado parece muito semelhante ao , não é verdade?docker containers

Você está certo em ambos os cenários. Mas com isso, por que precisamos de Lando para o nosso projeto, quando temos e ?docker composedocker containers

Usando Lando:

  • Temos acesso a um processo mais simplificado de definição de contêineres do Docker usando receitas predefinidas
  • Mesmo que nosso ambiente necessário não seja suportado pelas receitas do Lando, temos um processo mais fácil de definir um contêiner definindo um serviço Lando que apenas expõe as configurações necessárias em comparação com o . Isso pode nos ajudar a nos livrar da configuração e ter que digitar comandos longosdocker containerdocker composeDockerfilesdocker exec
  • No caso de ainda precisarmos de nossos próprios arquivos personalizados para definir o ambiente de desenvolvimento, podemos usá-los ao lado ou no lugar de receitas e serviços da Lando enquanto obtemos alguns benefícios extras, como redes de desenvolvimento local docker compose
  • Além disso, obtemos muito mais benefícios, como manipulação de SSL por contêiner, configuração de proxy e URLs personalizadas para cada serviço, etapas simplificadas de compilação e execução, configuração local de CI e muitas outras coisas. Leia mais sobre benefícios extras que você pode obter usando Lando aqui

Agora é hora de ver a Lando em ação e ver como ela pode nos ajudar em nosso trabalho de desenvolvimento. Começamos instalando o Lando e, em seguida, configurando-o para um projeto simples de servidor web NodeJS.

Instalar Lando

A primeira coisa que precisamos fazer é instalar Lando em nossa máquina. Aqui estão algumas coisas a ter em mente:

  • Verifique se o hardware da sua máquina atende aos requisitos para instalar o Lando
  • Verifique se o hardware da sua máquina atende aos requisitos para instalar o Docker Engine
  • Verifique se o sistema operacional da sua máquina atende aos requisitos
  • Verifique se você tem acesso de administrador em sua máquina (peça acesso ao operador se você estiver em uma rede)

No entanto, mesmo que você atenda aos requisitos, existem problemas com a instalação do Lando:

  • Mesmo que você atenda aos requisitos mínimos de hardware, há uma chance de Lando não funcionar sem problemas. Aqui estão os requisitos preferidos de Lando. Estou rodando Lando em uma máquina com essas características e não enfrentei nenhum problema até agora:
- 2,6 GHz 6-Core Intel Core i7
- 16 GB 2667 MHz DDR4
- 420GB+ of available disk space
  • Lando depende do Docker para execução e é por isso que o tamanho do arquivo de instalação é um pouco grande, já que a instalação compatível do Docker é fornecida com a instalação do Lando. Portanto, se você não tiver o Docker, ele será instalado como parte do processo de instalação do Lando

Se você já tiver o Docker, precisará saber que pode haver um problema de compatibilidade com sua versão do Docker e de qual versão do Docker o Lando depende. No entanto, você ainda pode ignorar a instalação do Docker dentro do processo de instalação do Lando. Como um protetor de segurança extra, você pode redefinir as configurações do Docker para os padrões de fábrica

  • Após verificar os requisitos acima. Siga o guia de instalação com base no seu sistema operacional aqui
  • Após a instalação, basta abrir um terminal em sua máquina e digitar o seguinte comando para se certificar de que a instalação foi bem-sucedida:
lando version
// You should get the version of Lando that you installed .
// v3.0.0-rrc.1

Inicializar Lando com o servidor HTTP de nó

Vamos construir um servidor HTTP Node simples juntos e usar Lando como uma ferramenta DevOPS para nos ajudar a executar, desenvolver e testar o projeto. Nosso objetivo, no final, é que, quando você puxar o exemplo de servidor Node do GitHub, você possa simplesmente digitar e ter todas as configurações em seu aplicativo prontas.lando start

Em primeiro lugar, vamos nos concentrar na criação do nosso aplicativo de servidor HTTP do Node.

Servidor HTTP do nó

O NodeJS é uma ferramenta poderosa para executar serviços do lado do servidor, aplicativos Web e ferramentas de front-end. Para este artigo, vamos nos concentrar em um de seus casos de uso mais comuns, que é configurar um servidor HTTP simples e lidar com roteamento básico.

Configurando o servidor HTTP

Usaremos módulos NodeJS populares chamados para lidar com isso; que é fornecido por padrão com NodeJS:http

// global dependencies
const http = require("http");

const requestHandler = function (req, res) {
  res.header('Content-type', 'text/html');
  res.end('I have built my own http server!');
};

http
  .createServer(requestHandler) //create a server object
  .listen(8080); //the server object listens on port 8080

Como você pode ver, tem um método chamado que retorna uma nova instância de http. Servidor, quando recebemos uma nova solicitação chegando via . Essa função aceita um objeto e .httpcreateServerrequestHandlerrequestresponse

Desta forma, podemos lidar com diferentes cenários quando diferentes parâmetros como entra e, consequentemente, enviar os resultados certos, como ou . Aqui estamos simplificando as coisas apenas definindo o corpo de resposta como um .requesturl pathresponseheaderresponse codestring

Essa configuração funciona para um exemplo simples, mas precisamos de um processo um pouco mais sofisticado para lidar com outros casos de uso comuns de aplicativos Web, como roteamento, tratamento de erros, processamento de solicitações e respostas. Uma opção que temos é usar um framework web como para este fim.Express

Vamos ver um exemplo de manipulação separada de solicitações que vêm com caminhos de URL diferentes:

// global dependencies
const http = require("http");
const express = require('express');
const app = express();

// request handlers
const homepageHandler = function (req, res) {
  res.header('Content-type', 'text/html');
  return res.end('I am on homepage');
};
const aboutpageHandler = function (req, res) {
  res.header('Content-type', 'text/html');
  return res.end('I am on about page');
};

http
  .createServer(app) //create a server object
  .listen(8080); //the server object listens on port 8080

// Basic HTTP response
app.get('/', homepageHandler);
app.get('/about', aboutpageHandler);

Depois de inicializar e passá-lo como um param para , o servidor começa a escutar na porta para caminhos de URL diferentes. Por exemplo, quando o navegador atinge a URL, invoca seu retorno de chamada que é . Veja você mesmo nesta sandbox:const app = express()createServer8080/aboutapp.get(‘/about’)aboutPageHandler

Configurar Lando

Agora que temos nosso aplicativo de servidor Node pronto, podemos nos concentrar na configuração do Lando. Vamos configurar um contêiner simples do Docker do Node com uma versão de patch suportada para o nosso projeto e, em seguida, lidar com alguns processos de etapa de compilação e servir o aplicativo na carga inicial. Como objetivo final, queremos explorar a configuração de dois contêineres do Docker para nosso projeto, um servindo a um servidor e o outro dando suporte ao servidor.httphttps

Há duas opções para definir as configurações básicas do Lando:

  • Invocando passando os parâmetros necessários para as receitas suportadas e deixando Lando configurar a configuração para nós. A partir de hoje, Lando suporta várias receitas como , , , , etc, então certifique-se de verificar se sua pilha necessária é suportada ou não lando init drupal joomla laralvel wordpress
  • Se a pilha necessária não for suportada, não se preocupe. Tudo o que você precisa é de um serviço que possa ser configurado criando um arquivo na raiz do aplicativolando.yml

Como nossa pilha de servidores NodeJS não é suportada pelas receitas atuais, vamos nos concentrar em criar a configuração nós mesmos. Começamos criando um arquivo no diretório raiz .lando.yml

Configurando a configuração base em lando.yml

Neste arquivo, vamos definir os serviços básicos que precisamos para o desenvolvimento de nossos aplicativos. Vamos começar definindo a base e chamada :namenode servicenode-http

// lando.yml
name: lando-node-server
services:
  node-http:
    type: node:12

Usamos o patch versão 12 do Node, que é compatível com nossa dependência:express

// express's node compatibility

"engines": {
  "node": ">=0.10.0"
}

Lando nos permite executar comandos no shell contra nossos serviços. Assim, podemos testar se a versão Node do contêiner que foi configurado com nosso serviço Lando está de fato correta:defaults

// terminal
lando ssh --service defaults --command "env | grep NODE_VERSION"

// You get
NODE_VERSION=12.16.2
// which is what we expect

Etapas de compilação

Como primeiro passo, vamos nos concentrar nas etapas de compilação do aplicativo. Em geral, temos quatro parâmetros de configuração para instalar dependências ou construir o aplicativo em nosso serviço. Essas configurações são compiladas, build_as_root run_ run_as_root. Por favor, note que esses comandos só são executados na primeira vez que Lando inicializa nosso aplicativo. Caso queiramos que as etapas de compilação sejam executadas novamente, podemos invocar o .lando rebuild

Por exemplo, nos permite instalar dependências usando o que é necessário antes que nosso aplicativo possa ser executado. Se precisarmos instalar um pacote de servidor de baixo nível que precise de acesso de administrador, podemos usar aqui.buildyarnbuild_as_root

Vamos tentar:

// lando.yml

name: lando-node-12
services:
  defaults:
    type: node:12
    build: yarn

// Result we get in terminal
Your app has started up correctly.
Here are some vitals:

 NAME           lando-node-12                        
 LOCATION       /Users/USERNAME/Projects/node12
 SERVICES       defaults

Portanto, neste ponto, se executarmos no terminal, o Lando configurará contêineres do Docker com a versão de patch especificada que definimos para o Node, executará nossa etapa de compilação e instalará todas as dependências no .lando startpackage.json

Servir/executar o recipiente

Então, temos nossas dependências resolvidas, mas que tal executar o aplicativo em si. Não queremos digitar outro comando para executar o aplicativo depois que seu contêiner de serviço for inicializado.

Acontece que o que tínhamos na etapa anterior é um contêiner CLI para nosso serviço, no qual podemos executar comandos para executá-lo. É exatamente isso que vamos fazer na configuração para automatizar essa etapa também:lando.yml

// lando.yml

name: lando-node-12
services:
  defaults:
    ...
    command: /app/node_modules/.bin/nodemon src/app-http.js --watch src

// Now we get a URL where our application is served
Your app has started up correctly.
Here are some vitals:
DEFAULTS URLS  http://localhost:32847

Para verificar onde as dependências foram instaladas em nosso contêiner, podemos entrar em nosso serviço assim:ssh

// listing all the files in the root directory
lando ssh --service defaults --command "ls -ls /"

// we get several folders listed in our container
0 drwxr-xr-x  10 node dialout  320 Apr 12 19:48 app
4 drwxr-xr-x   1 root root    4096 Mar 31 02:07 bin
4 drwxr-xr-x   2 root root    4096 Feb  1 17:09 boot
...

// We then try to cd to places we assume hold the no_modules intallation
lando ssh -t --service defaults --command 'cd /app && exec bash -l'

// and we see our node_modules directory here under app/
README.md  node_modules  package.json  src  yarn.lock

Usando SSL

Vamos girar outro contêiner de serviço para ver como mais de um serviço pode ser tratado pela Lando. O serviço extra que vamos construir vai estabelecer um servidor HTTPS seguro para o nosso ambiente de desenvolvimento.

A maneira como podemos fazer isso é através de um certificado auto-assinado que geralmente é construído usando OpenSSL, mas isso é algo que Lando irá lidar para nós. O certificado e os arquivos de chave estarão localizados no diretório, que podemos usar em um novo servidor Node para proteger uma determinada porta (que por padrão está no Lando). Vejamos isso em ação:/certs443

//app-https.js

'use strict';

// global dependencies
const fs = require('fs');
const http = require('http');
const https = require('https');
const express = require('express');

// initialization
const app = express();
const key = fs.readFileSync('/certs/cert.key');
const cert = fs.readFileSync('/certs/cert.crt');

// request handlers
const homepageHandler = function (req, res) {
  res.header('Content-type', 'text/html');
  return res.end('I am on homepage');
};

const aboutpageHandler = function (req, res) {
  res.header('Content-type', 'text/html');
  return res.end('I am on about page');
};

// Create our servers
https.createServer({key, cert}, app).listen(443);
http.createServer(app).listen(3000);

// Basic HTTP response
app.get('/', homepageHandler);
app.get('/about', aboutpageHandler);

// lando.yml
// setting a new service for a node server with SSL support

name: lando-node-12
services:
  ...
  custom:
    type: node:12
    ssl: true
    port: 3000
    build:
      - yarn
    command: /app/node_modules/.bin/nodemon src/app-https.js --watch src --ignore *.test.js

Agora, depois de executar, podemos ver que temos dois serviços em funcionamento:lando rebuild

NAME           lando-node-12                        
 LOCATION       /Users/USERNAME/Projects/node12
 SERVICES       defaults, custom                     
 DEFAULTS URLS  http://localhost:32898               
 CUSTOM URLS    http://localhost:32899               
                https://localhost:32900

Também depois de invocar em serviço, podemos ver quais arquivos de certificado são gerados:sshcustom

lando ssh -t --service defaults --command 'cd /certs && ls'

// generated certificates
cert.crt  cert.csr  cert.ext  cert.key  cert.pem  server.crt  server.key

Neste ponto, se formos para a URL fornecida, veremos que o navegador está reclamando sobre o certificado ser inválido. Isso é bom porque nós assinamos por conta própria.https://localhost:32900

Depois de prosseguir nesta página, podemos ver que a conexão HTTPS foi estabelecida com êxito:

Para saber mais sobre como lidar com SSL no Lando, leia este guia completamente.

Testando a configuração

Agora, é hora de testar nossa configuração. Imagine que você é um novo desenvolvedor em uma equipe e deseja trabalhar neste repositório de servidor Node. Tudo o que você precisa fazer é puxar este repositório do Github, instalar o Lando em sua máquina e executar e pronto.lando start

Conclusão

untos, examinamos e construímos um processo simples para construir e executar nosso ambiente de desenvolvimento para um servidor web Node.

Próximos passos?

Há muito mais coisas que podemos explorar com Lando:

  • Não deixe de ler mais a fundo sobre as receitas e serviços da Lando. Adicione outros para diferentes partes de sua pilha, como banco de dados, frontend, api, monitoramento e ferramentas de análise
  • Se você precisa de um processo de ferramental complexo, você pode considerar o uso de ferramentas Lando. Com isso, você pode criar etapas de compilação complicadas em todos os seus contêineres com apenas um comando. Além disso, você pode configurar seu teste de CI em ferramentas e executá-lo localmente
  • Considere otimizar o processo de execução e criação de contêineres do Docker com o Lando
  • E o mais importante, resolver problemas que valem a pena resolver. Não se envolva em engenharia excessiva e concentre-se apenas na criação de configurações que acontecem mais de uma vez no ciclo de vida do aplicativo

Recursos

  • https://www.edureka.co/blog/what-is-docker-container
  • https://nodejs.org/en/knowledge/HTTP/servers/how-to-create-a-HTTP-server/
  • https://developer.mozilla.org/en-US/docs/Learn/Server-side/Express_Nodejs/Introduction
  • https://flaviocopes.com/express-https-self-signed-certificate/
  • https://docs.lando.dev/guides/lando-info.html

Artigo Original