earthly
v0.8.15
? Construções repetíveis - Escreva as compra uma vez e execute -as em qualquer lugar - no seu laptop, remoto e em qualquer IC.
❤️ Super simples - sintaxe instantaneamente reconhecível - como Dockerfile e Makefile tive um bebê.
? Compatível com todas as idiomas, estrutura e ferramenta de construção - se for executado no Linux, ele é executado no terreno.
? Ótimo para monorepos e poliprepos - Organize sua lógica de construção, no entanto, faz mais sentido para o seu projeto.
? Construções rápidas - Construa cache e execução paralela torna as compilações rapidamente automaticamente.
♻️ Reutilização, não repita - nunca escreva o mesmo código em várias compilações novamente.
? O terreno é uma estrutura de CI/CD versátil e acessível que executa todos os contêineres dentro de contêineres, oferecendo compilações repetíveis que você escreve uma vez e executa em qualquer lugar. Possui uma sintaxe super simples e instantaneamente reconhecível que é fácil de escrever e entender - como o Dockerfile e o Makefile teve um bebê. E ele aproveita e aumenta as ferramentas de construção populares em vez de substituí -las, para que você não precise reescrever todas as suas compilações, independentemente das línguas que você usa.
As execuções terrestres todas as construções em recipientes, tornando-os independentes, isolados, repetíveis e portáteis. Isso permite uma iteração mais rápida sobre scripts de construção e depuração mais fácil quando algo dá errado -não há mais git commit -m "try again" . Quando você escreve uma compilação, você sabe que será executado corretamente, não importa onde ele seja executado - seu laptop, um laptop de colega ou qualquer IC. Você não precisa configurar ferramentas específicas de linguagem, instalar dependências adicionais ou complicar seus scripts de compilação para garantir que eles sejam compatíveis com OSS diferentes. O terreno oferece compilações consistentes e repetíveis, independentemente de onde elas correm.
A sintaxe da Earthly é fácil de escrever e entender. A maioria dos engenheiros pode ler um arquivo Earth instantaneamente, sem o conhecimento prévio do terreno. Combinamos algumas das melhores idéias do Dockerfiles e Makefiles em uma especificação - como Dockerfile e Makefile, tiveram um bebê.
Trabalhos terrestres com os compiladores e as ferramentas de construção que você usa. Se for executado no Linux, será executado na terra. E você não precisa reescrever suas construções existentes ou substituir os arquivos package.json , go.mod , build.gradle ou Cargo.toml . Você pode usar o terreno como um invólucro em torno de suas ferramentas existentes e ainda obter compilações repetíveis da Terra, execução paralela e criação de cache.
Terreno é ótimo para monorepos e poliprepos. Você pode dividir sua lógica de construção em vários arquivos de terra, colocando alguns profundos dentro da estrutura do diretório ou mesmo em outros repositórios. A referência de alvos de outros arquivos de terra é fácil, independentemente de onde sejam armazenados. Assim, você pode organizar sua lógica de construção, no entanto, faz mais sentido para o seu projeto.
O terreno executa automaticamente a criação de metas em paralelo e faz o máximo de uso do cache. Isso torna as construções rapidamente. A Earthly também possui poderosos recursos de cache compartilhados que aceleram as construções frequentemente atravessam uma equipe ou em ambientes de caixa de areia, como satélites terrestres, ações do GitHub ou seu IC.
Se a sua construção tiver várias etapas, o terreno será:
Nunca mais preciso escrever o mesmo código em várias compilações. Com o terreno, você pode reutilizar alvos, artefatos e imagens em vários arquivos de terra, até mesmo em outros repositórios, em uma única linha. Terreno é consciente do cache, com base nos hashes individuais de cada arquivo, e compartilhou recursos de cache. Assim, você pode criar uma hierarquia de construção vasta e eficiente que execute apenas as etapas mínimas necessárias.
Terrestre deve ser usado tanto na sua máquina de desenvolvimento quanto no IC. Ele é executado na parte superior da sua plataforma CI/CD (como Jenkins, Circle CI, Github Actions e Gitlab CI/CD). A Earthly fornece os benefícios de um sistema moderno de automação de compilação onde quer que ele seja executado - como cache e paralelismo. É uma camada de cola entre as ferramentas de construção específicas da linguagem (como Maven, Gradle, NPM, PIP, Go Build) e CI, trabalhando como um invólucro em torno de suas ferramentas de construção e lógica de construção que os isolados criam a execução dos ambientes em que correm.
Em resumo: recipientes , cache de camadas e gráficos de construção complexos !
Executa terrestre construídos em recipientes, onde a execução é isolada. As dependências da construção são explicitamente especificadas na definição de construção, tornando a construção auto-suficiente.
Usamos um sistema baseado em destino para ajudar os usuários a interromper as construções complexas em peças reutilizáveis. Nada é compartilhado entre alvos diferentes de dependências claramente declaradas. Nada compartilhado significa condições inesperadas de raça. De fato, a compilação é executada em paralelo sempre que possível, sem a necessidade de o usuário cuidar de quaisquer interações ambientais de bloqueio ou inesperadas.
Nota Earthfiles pode parecer muito semelhante às compilações com vários estágios do Dockerfile. De fato, a mesma tecnologia é usada por baixo. No entanto, uma diferença importante é que o terreno é projetado para ser um sistema de construção de uso geral, não apenas uma especificação de imagem do Docker. Leia mais sobre como a terra é diferente dos Dockerfiles.
Consulte as instruções de instalação.
Para construir a partir da fonte, verifique a página que contribui.
Aqui estão alguns recursos para você começar com o terreno
Veja também a documentação completa.
Páginas de referência
# Earthfile
VERSION 0.8
FROM golang:1.15-alpine3.13
RUN apk --update --no-cache add git
WORKDIR /go-example
all :
BUILD +lint
BUILD +docker
build :
COPY main.go .
RUN go build -o build/go-example main.go
SAVE ARTIFACT build/go-example AS LOCAL build/go-example
lint :
RUN go get golang.org/x/lint/golint
COPY main.go .
RUN golint -set_exit_status ./...
docker :
COPY +build/go-example .
ENTRYPOINT [ "/go-example/go-example" ]
SAVE IMAGE go-example:latest // main.go
package main
import "fmt"
func main () {
fmt . Println ( "hello world" )
} Invoque a construção usando earthly +all .
Exemplos para outros idiomas estão disponíveis nos exemplos dir.
Sempre que possível, o terreno executa automaticamente os alvos em paralelo.
Reduza os tempos de construção no CI através do cache remoto compartilhado.
Construir para várias plataformas em paralelo.
VERSION 0.8
all :
BUILD
--platform = linux/amd64
--platform = linux/arm64
--platform = linux/arm/v7
--platform = linux/arm/v6
+build
build :
FROM alpine:3.18
CMD [ "uname" , "-m" ]
SAVE IMAGE multiplatform-image Não há necessidade de pedir à sua equipe para instalar protoc , uma versão específica do Python, Java 1.6 ou o ecossistema .NET Core. Instale uma vez no seu arquivo Earth e ele funciona para todos. Ou melhor ainda, você pode simplesmente usar o rico ecossistema de hub do Docker.
VERSION 0.8
FROM golang:1.15-alpine3.13
WORKDIR /proto-example
proto :
FROM namely/protoc-all:1.29_4
COPY api.proto /defs
RUN --entrypoint -- -f api.proto -l go
SAVE ARTIFACT ./gen/pb-go /pb AS LOCAL pb
build :
COPY go.mod go.sum .
RUN go mod download
COPY +proto/pb pb
COPY main.go ./
RUN go build -o build/proto-example main.go
SAVE ARTIFACT build/proto-exampleVeja o código de exemplo completo.
O terreno pode ser usado para fazer referência e criar alvos de outros diretórios ou mesmo de outros repositórios. Por exemplo, se quiséssemos construir um exemplo de alvo no repositório github.com/earthly/earthly , poderíamos emitir
# Try it yourself! No need to clone.
earthly github.com/earthly/earthly/examples/go:main+docker
# Run the resulting image.
docker run --rm earthly/examples:go Use + para fazer referência a outros alvos e criar interdependências de construção complexas.
Exemplos
Mesmo diretório (mesmo arquivo Earth)
BUILD +some-target
FROM +some-target
COPY +some-target/my-artifact ./Outros diretórios
BUILD ./some/local/path+some-target
FROM ./some/local/path+some-target
COPY ./some/local/path+some-target/my-artifact ./Outros repositórios
BUILD github.com/someone/someproject:v1.2.3+some-target
FROM github.com/someone/someproject:v1.2.3+some-target
COPY github.com/someone/someproject:v1.2.3+some-target/my-artifact ./Os segredos nunca são armazenados dentro das camadas de uma imagem e estão disponíveis apenas para os comandos que precisam deles.
earthly set /user/github/token ' shhh... ' release :
RUN --push --secret GITHUB_TOKEN = user/github/token github-release upload file.binO Dockerfiles foi projetado para especificar a composição das imagens do Docker e é aí que o Dockerfiles param. O terreno leva alguns princípios -chave dos dockerfiles (como cache de camada), mas expande os casos de uso. Por exemplo, o terreno pode gerar artefatos regulares, executar testes de unidade e integração e criar várias imagens do Docker por vez - tudo fora do escopo do DockerFiles.
É possível usar o DockerFiles em combinação com outras tecnologias (por exemplo, arquivos makefiles ou bash) para resolver esses casos de uso. No entanto, essas combinações são difíceis de paralelizar, desafiador para escalar entre os repositórios, pois não possuem um sistema de importação robusto e geralmente variam em grande estilo de uma equipe para outra. A terra não possui essas limitações, pois foi projetada como um sistema de construção de uso geral.
Por exemplo, a Earthly apresenta um sistema mais rico de alvo, artefato e referência de imagem, permitindo uma melhor reutilização em construções complexas que abrangem um único repositório grande ou vários repositórios. Como o Dockerfiles é destinado apenas a descrever uma imagem de cada vez, esses recursos estão fora do escopo da aplicabilidade dos dockerfiles.
Confira a página do Doc do EarthFile Reference. Ele possui todos os comandos lá e especifica quais comandos são os mesmos dos comandos do Dockerfile e quais são novos.
Sim! Você pode usar o comando FROM DOCKERFILE para herdar os comandos em um Dockerfile existente.
build :
FROM DOCKERFILE .
SAVE IMAGE some-image:latestOpcionalmente, você também pode portar seus dockerfiles para o terreno. A tradução de dockerfiles para os arquivos de terra é geralmente uma questão de pasting e fazer pequenos ajustes. Veja a página de início para alguns exemplos do EarthFile.
O Bazel é uma ferramenta de construção desenvolvida pelo Google para otimizar a velocidade, a correção e a reprodutibilidade de sua base de código Monorepo interna. A principal diferença entre Bazel e Terrestre é que o Bazel é um sistema de construção , enquanto o terreno é uma estrutura de IC/CD de uso geral . Para uma explicação mais aprofundada, consulte nossas perguntas frequentes.
Terrestre é licenciado sob a licença pública de Mozilla versão 2.0. Consulte a licença.
