Há muito tempo que usamos contêineres para empacotamento de software. Mas vamos enfrentá-lo, a experiência do usuário do Docker não é realmente a melhor. Construir e testar geralmente envolve ter um monte de Makefiles, Dockerfiles complicados, um pouco de magia negra e um pacote de scripts Bash. É um caminho que pode levar à insanidade.

E é uma pena, porque Docker poderia ser muito mais amigável. Desenvolvedores terrestres certamente acreditam nisso: eles criaram uma ferramenta que preenche o espaço entre o Docker e o Make.

No final deste tutorial, você saberá como funciona o Earthly. Como bônus, você terá um pipeline que constrói, testa e envia uma imagem Docker para um repositório remoto.

Como funciona o Earthly

Earthly é uma ferramenta de construção baseada em Docker. No entanto, ele não substitui ferramentas específicas do idioma, como Maven, Gradle ou Webpack. Em vez disso, ele aproveita e se integra a eles - agindo como uma cola.

Usando contêineres do Docker como a mecânica central para alcançar a repetibilidade, cada comando terrestre é executado em um ambiente isolado e é paralelizado sem esforço sempre que possível.

O Earthly consiste no binário CLI e em uma imagem Docker chamada earthly / buildkit , com base no BuildKitd do Docker .

Os desenvolvedores terrestres desejam que você tenha a mesma experiência em todos os lugares. A função do BuildKit é produzir camadas portáteis compatíveis com o Docker. Assim, obtemos o mesmo resultado em nossa máquina local e em nossos sistemas de CI.

O Earthly cumpre suas promessas?

O terreno promete construções melhores e reproduzíveis. Mas, ele cumpre? Aqui estão alguns dos melhores recursos e alguns dos problemas encontrados ao fazer um test drive.

Prós:

• Terrestre, como Docker, é agnóstico de linguagem. Sua sintaxe parece familiar, pois combina Make e Dockerfiles.
• O site deles tem boa documentação.
• A configuração exige pouca manutenção. Existem apenas algumas configurações para ajustar.
• Útil mesmo nos casos em que você não precisa do Docker. As imagens de contêiner são apenas uma das saídas possíveis. Por exemplo, você pode usar o Earthly para testar e compilar binários em um ambiente limpo.
• O sistema de importação funciona bem em multirepo e monorepos .

• Na verdade, ele não substitui o Makefile ou o Docker Compose. E você ainda precisará de alguns scripts de shell.
• É mais lento que o Docker nativo porque depende da cópia de arquivos em vez de montagens. Obviamente, isso ocorre por design para garantir a repetibilidade.
• As compilações de multiplataforma às vezes usam emulação , por isso pode ser muito lento para alguns casos de uso.
• As mensagens de erro podem ser muito confusas.

Os arquivos de configuração terrestre são chamados, como típicos da engenharia de software Earthfiles,. Abrir um nos lembra de Dockerfiles com um toque de Makefiles.

O Earthly pega a sintaxe do Docker e a expande para um caso de uso geral. Enquanto os Dockerfiles se destinam apenas a produzir imagens de contêiner, o Earthly pode gerar artefatos.

O seguinte Earthfile foi retirado do guia oficial do Earthly. Ele descreve dois alvos: builde docker.

FROM golang:1.15-alpine3.13
WORKDIR /go-example

build:
    COPY main.go .
    RUN go build -o build/go-example main.go
    SAVE ARTIFACT build/go-example /go-example AS LOCAL build/go-example

docker:
    COPY +build/go-example .
    ENTRYPOINT ["/go-example/go-example"]
    SAVE IMAGE go-example:latest

A FROMpalavra-chave funciona como você esperaria se estivesse familiarizado com Dockerfiles. Da mesma forma, COPY, ENTRYPOINT, WORKDIR, e RUN, se comportam de forma semelhante. Dois conceitos merecem uma pausa para uma explicação mais detalhada:

• alvos : aquilo que queremos construir. Earthly usa um sistema baseado em alvos inspirado em Make.
• referências : os alvos podem fazer referência a outros alvos. Como no Make, o Earthly classificará as dependências e fará a coisa certa.
• Comandos estendidos : o Earthly oferece comandos especializados, como SALVAR IMAGEM e SALVAR ARTIFATO.

$ earthly +build

           buildkitd | Found buildkit daemon as docker container (earthly-buildkitd)
golang:1.15-alpine3.13 | --> Load metadata linux/arm64
             context | --> local context .
               +base | --> FROM golang:1.15-alpine3.13
             context | transferred 1 file(s) for context . (2.1 MB, 4 file/dir stats)
               +base | *cached* --> WORKDIR /go-example
              +build | *cached* --> COPY main.go .
              +build | *cached* --> RUN go build -o build/go-example main.go
              output | --> exporting outputs
================================ SUCCESS [main] ================================
              +build | Artifact +build/go-example as local build/go-example

$ earthly +docker

               +base | --> FROM golang:1.15-alpine3.13
               +base | *cached* --> WORKDIR /go-example
             context | transferred 3 file(s) for context . (2.1 MB, 4 file/dir stats)
              +build | *cached* --> COPY main.go .
              +build | *cached* --> RUN go build -o build/go-example main.go
              +build | *cached* --> SAVE ARTIFACT build/go-example +build/go-example AS LOCAL build/go-example
             +docker | --> COPY +build/go-example ./
              output | [██████████] exporting layers ... 100%
              output | [          ] exporting manifest
================================ SUCCESS [main] ================================
             +docker | Image +docker as go-example:latest
              +build | Artifact +build/go-example as local build/go-example

Extending Earthfiles

Vamos tentar o Earthly em um exemplo mais envolvente. Vá em frente e bifurque este repositório de demonstração .

O Dockerfile fornecido cria uma imagem de contêiner Node Alpine.

FROM node:14.17-alpine3.12
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm install
COPY src src
EXPOSE 3000
ENTRYPOINT ["npm", "start"]

Como faríamos para transformar isso em um arquivo da terra funcional? Vamos começar do zero.

As primeiras duas linhas permanecem as mesmas e serão usadas para todos os alvos.

FROM node:14.17-alpine3.12
WORKDIR /app

build:
    COPY package.json package-lock.json ./
    COPY --if-exists node_modules node_modules
    RUN npm install
    COPY src src

Como o npm é executado no contêiner, precisamos copiar seus arquivos de saída de volta para fora. Fazemos isso com o comando especial do Earthly SAVE ARTIFACT ... AS LOCAL.

SAVE ARTIFACT node_modules AS LOCAL ./node_modules
    SAVE ARTIFACT package.json AS LOCAL ./package.json
    SAVE ARTIFACT package-lock.json AS LOCAL ./package-lock.json

Em seguida, devemos criar a imagem Docker. Podemos conseguir isso com:

docker:
    FROM +build
    EXPOSE 3000
    ENTRYPOINT ["npm", "start"]
    SAVE IMAGE semaphore-demo-earthly:latest

Testando com o Earthly

Um dos recursos mais poderosos que o Earthly traz é a capacidade de estender Dockerfiles com testes. Testes de unidade add deixou-nos através do alargamento buildcom um alvo que corre: npm test.

tests:
    FROM +build
    COPY spec spec
    RUN npm test

Adicionar um alvo linting também é trivial:

lint:
    FROM +build
    COPY .jshintrc ./
    RUN npm run lint

integration-tests:
    FROM +build
    COPY docker-compose.yml ./
    COPY integration-tests integration-tests
    WITH DOCKER --compose docker-compose.yml --service db
        RUN sleep 10 && npm run integration-tests
    END

1. Cópias docker-compose.ymle testes de integração no contêiner principal (o contêiner do aplicativo).
2. Inicia um contêiner PostgreSQL dentro do contêiner principal. O WITH DOCKERcomando especial aceita precisamente uma RUN declaração.
3. Executa os testes de integração.

$ git add Earthfile
$ git commit -m "push Earthfile"
$ git push origin master

Agora estamos prontos para testar o aplicativo com integração terrestre e contínua . Nosso pipeline puxará e enviará do Docker Hub, algo que exigirá autenticação com o serviço.

A autenticação no Semaphore acontece por meio de segredos . Para criar um segredo criptografado, vá para o menu da sua organização e clique em Configurações> Segredos. Em seguida, pressione Criar segredo e digite as variáveis DOCKER_USERNAMEe DOCKER_PASSWORDconforme mostrado abaixo:

Em seguida, inicialize o repositório de demonstração bifurcado. O procedimento para adicionar um projeto é detalhado no guia de introdução . Vá verificar se esta é a primeira vez que usa o Semaphore.

Como o Earthly não vem pré-instalado na imagem do Ubuntu CI , precisamos instalá-lo para cada trabalho. A maneira mais simples de conseguir isso é com um prólogo no nível do pipeline . Os comandos no prólogo global são executados antes de cada trabalho no pipeline.

O comando de instalação do Earthly para Linux é:

sudo /bin/sh -c 'wget https://github.com/earthly/earthly/releases/latest/download/earthly-linux-amd64 -O /usr/local/bin/earthly && chmod +x /usr/local/bin/earthly && /usr/local/bin/earthly bootstrap --with-autocomplete'

Bloco de construção

O primeiro bloco iniciará um estágio de construção . Nele, vamos baixar e armazenar em cache as dependências do Node.

Digite os seguintes comandos no trabalho:

echo "${DOCKER_PASSWORD}" | docker login -u "${DOCKER_USERNAME}" --password-stdin
checkout
cache restore
earthly --ci +build
cache store

• docker login : faz login no Docker Hub com as credenciais definidas no segredo.
• checkout : clona o repositório na máquina CI .
• cache : Com o comando cache , podemos armazenar node_modulesno armazenamento de nível de projeto fornecido pelo Semaphore.
• earthly ci : executa o Earthly com algumas configurações otimizadas para CI.

Bloco de testes

O próximo bloco executará testes rápidos, como testes de unidade e linting. Adicione os seguintes comandos no prólogo do bloco :

echo "${DOCKER_PASSWORD}" | docker login -u "${DOCKER_USERNAME}" --password-stdin
checkout
cache restore

      

earthly --ci +tests

earthly --ci +lint

      

O último trabalho executará o teste de integração. Digite os seguintes comandos. A -Popção é necessária para habilitar o modo privilegiado dentro do Docker (necessário para o Docker-in-Docker).

echo "${DOCKER_PASSWORD}" | docker login -u "${DOCKER_USERNAME}" --password-stdin
checkout
cache restore
earthly --ci -P +integration-tests

      

Entrega contínua com terrestre

O resultado final de um pipeline de CI / CD é entregar algo que pode ser implantado. É aqui que entra em jogo a parte da entrega contínua . Enviaremos a imagem para um repositório remoto para que possa ser implantada posteriormente na produção.

Um fluxo de trabalho do Semaphore pode abranger vários pipelines, desde que estejam conectados por promoções . Volte para o editor de fluxo de trabalho e clique em Adicionar promoção . Clique no novo pipeline e copie os comandos globais de instalação do Earthly, novamente:

sudo /bin/sh -c 'wget https://github.com/earthly/earthly/releases/latest/download/earthly-linux-amd64 -O /usr/local/bin/earthly && chmod +x /usr/local/bin/earthly && /usr/local/bin/earthly bootstrap --with-autocomplete'

echo "${DOCKER_PASSWORD}" | docker login -u "${DOCKER_USERNAME}" --password-stdin
checkout
cache restore
earthly +docker
docker tag semaphore-demo-earthly $DOCKER_USERNAME/semaphore-demo-earthly
docker push $DOCKER_USERNAME/semaphore-demo-earthly

A única coisa que resta é habilitar o segredo do Docker Hub ... e pronto!

Execute novamente o fluxo de trabalho e clique em promover para tentar enviar a imagem.

O que você acha?

O projeto Earthly é jovem e está em forte desenvolvimento, com muitos recursos ainda em fase experimental (mantivemos os recursos estáveis ​​no decorrer do post). Não é perfeito, mas parece um grande passo na direção certa.

Aprimore seu conhecimento do Docker com estes tutoriais:

• Kubernetes vs. Docker: noções básicas sobre contêineres em 2021
• Como implantar um aplicativo da Web Go com Docker
• Dockerizing a Node.js Web Application
• Dockerizing um aplicativo Ruby on Rails

Publicado originalmente em https://semaphoreci.com em 15 de setembro de 2021.