Hoje temos o prazer de anunciar um novo projeto de código aberto, tentilhão. Finch é um novo cliente de linha de comando para criar, executar e publicar contêineres do Linux. Ele fornece a instalação simples de um cliente macOS nativo, juntamente com um conjunto curado de componentes de código aberto padrão de fato, incluindo Lima, nerdctl, contêinere BuildKit. Com o Finch, você pode criar e executar contêineres localmente e criar e publicar imagens de contêiner da Open Container Initiative (OCI).

No lançamento, o Finch é um novo projeto em seus primórdios com funcionalidade básica, inicialmente suportando apenas o macOS (em todas as arquiteturas de CPU do Mac). Em vez de iterar em particular e lançar um projeto finalizado, sentimos que o código aberto é mais bem-sucedido quando diversas vozes vêm à festa. Temos planos de recursos e inovações, mas abrir o projeto tão cedo levará a uma solução mais robusta e útil para todos. Temos o prazer de resolver os problemas e estamos prontos para aceitar solicitações pull. Também estamos esperançosos de que, com a adoção desses componentes de código aberto dos quais o Finch é composto, aumentaremos o foco e a atenção nesses componentes e adicionaremos mais mãos ao importante trabalho de manutenção e administração de código aberto. Em particular, Justin Cormack, CTO da Docker compartilhou que “estamos otimistas sobre a adoção do containerd e do BuildKit por Finch e esperamos que a AWS trabalhe conosco em contribuições upstream”.

Estamos entusiasmados em construir o Finch ao ar livre com colaboradores interessados. Queremos expandir o Finch de seu ponto de partida básico atual para cobrir as plataformas Windows e Linux e funcionalidades adicionais que colocamos em nosso roteiro, mas também adoraríamos suas ideias. Por favor, abra questões ou arquive pull requests e comece a discutir suas ideias conosco no Canal Finch Slack. Finch é licenciado sob a licença Apache 2.0 e qualquer um pode usá-lo livremente.

Por que construir o Finch?

Para construir e executar containers Linux em hosts não-Linux, existem produtos comerciais existentes, bem como uma variedade de projetos de software livre criados especificamente para esse fim. Embora as empresas possam montar uma ferramenta de linha de comando simples a partir de componentes de código aberto existentes, a maioria das organizações deseja que seus desenvolvedores se concentrem na construção de seus aplicativos, não na construção de ferramentas.

Na AWS, começamos a analisar os componentes de código aberto disponíveis para ferramentas de contêiner e ficamos imediatamente impressionados com o progresso de Lima, recentemente incluído no Cloud Native Computing Foundation (CNCF) como um projeto sandbox. O objetivo de Lima é promover containerd e nerdctl para usuários de Mac, e isso se alinha muito bem com nosso investimento existente tanto no uso quanto na contribuição para o projeto graduado do CNCF, containerd. Em vez de introduzir outra ferramenta e fragmentar os esforços de código aberto, a equipe decidiu se integrar a Lima e está fazendo contribuições ao projeto. Akihiro Suda, criador de nerdctl e Lima e mantenedor de longa data de containerd, BuildKit e runc, acrescentou: “Estou animado em ver a AWS contribuindo para nerdctl e Lima e muito feliz em ver a comunidade crescendo em torno desses projetos. Estou ansioso para colaborar com os colaboradores da AWS para melhorar Lima e nerdctl ao lado de Finch.”

Finch é nossa resposta à complexidade de selecionar e montar uma ferramenta de desenvolvimento de contêiner de código aberto para macOS inicialmente, seguido por Windows e Linux no futuro. Estamos selecionando os componentes, dependendo diretamente do Lima e do nerdctl, e empacotando-os junto com suas dependências em um instalador simples para macOS. O Finch, por meio de seu cliente nativo do macOS, atua como uma passagem para o nerdctl, que é executado em uma máquina virtual gerenciada por Lima. Todas as partes móveis são abstraídas por trás do cliente Finch simples e fácil de usar. Finch gerencia e instala todos os componentes de código aberto necessários e suas dependências, eliminando qualquer necessidade de você gerenciar atualizações e correções de dependências.

O principal cliente Finch sempre será uma distribuição com curadoria composta inteiramente de projetos de código aberto e neutros em relação ao fornecedor. Também queremos que o Finch seja personalizável para que os consumidores downstream criem suas próprias extensões e recursos de valor agregado para casos de uso específicos. Sabemos que os clientes da AWS desejam extensões que facilitem a integração de contêineres locais com os serviços de nuvem da AWS. No entanto, essas serão extensões opcionais que não afetam ou fragmentam o núcleo de código aberto ou as dependências upstream das quais Finch depende. As extensões serão mantidas como projetos separados com seus próprios ciclos de lançamento. Achamos que esse modelo atinge um equilíbrio perfeito para fornecer recursos específicos e, ao mesmo tempo, colaborar abertamente com o Finch e suas dependências upstream. Como o projeto é de código aberto, o Finch fornece um excelente ponto de partida para quem deseja criar seu próprio cliente de contêiner personalizado.

Em resumo, com Finch, selecionamos uma pilha comum de componentes de código aberto que são criados e testados para funcionar juntos e os combinamos com uma ferramenta nativa simples. Finch é um projeto com muito conhecimento de container coletivo por trás dele. Nosso objetivo é fornecer uma experiência mínima e simples de build/run/push/pull, focada nos principais comandos do fluxo de trabalho. À medida que o projeto evolui, trabalharemos para tornar o componente de virtualização mais transparente para desenvolvedores com um espaço menor e tempos de inicialização mais rápidos, além de buscar uma estrutura de extensibilidade para que você possa personalizar o Finch como quiser.

Com o tempo, esperamos que a Finch se torne um campo de testes para novas ideias, bem como uma forma de oferecer suporte a nossos clientes existentes que nos solicitaram uma ferramenta de desenvolvimento de contêiner de código aberto. Embora uma conta da AWS não seja necessária para usar o Finch, se você for um cliente da AWS, forneceremos suporte de acordo com seus planos atuais do AWS Support ao usar o Finch junto com os serviços da AWS.

O que você pode fazer com Finch?

Como o Finch é integrado diretamente ao nerdctl, todos os comandos e opções típicos com os quais você se tornou fluente funcionarão da mesma forma como se você estivesse executando nativamente no Linux. Você pode extrair imagens de registros, executar contêineres localmente e criar imagens usando seus Dockerfiles existentes. O Finch também permite que você crie e execute imagens para arquiteturas amd64 ou arm64 usando emulação, o que significa que você pode criar imagens para qualquer uma (ou ambas) arquiteturas de seu M1 Apple Silicon ou Mac baseado em Intel. Com o lançamento inicial, o suporte para volumes e redes está em vigor, e o Compose é compatível para executar e testar vários aplicativos de contêiner.

Depois de instalar o Finch a partir do repositório do projeto, você pode começar a criar e executar contêineres. Conforme mencionado anteriormente, para nosso lançamento inicial, apenas o macOS é compatível.

Para instalar o Finch no macOS, baixe o pacote de lançamento mais recente. Abrir o arquivo do pacote o guiará pela experiência padrão de instalação de um aplicativo macOS.

Finch não tem interface gráfica no momento e oferece um cliente de linha de comando simples sem integrações adicionais para gerenciamento de cluster ou outras ferramentas de orquestração de contêiner. Com o tempo, estamos interessados ​​em adicionar extensibilidade ao Finch com recursos opcionais que você pode optar por habilitar.

Após a instalação, você deve inicializar e iniciar o ambiente virtual do Finch. Execute o seguinte comando para iniciar a VM:
finch vm init

Para iniciar o ambiente virtual do Finch (por exemplo, após reinicializações), execute:
finch vm start

Agora, vamos executar um contêiner simples. O comando de execução extrairá uma imagem, se ainda não estiver presente, e criará e iniciará a instância do contêiner. o —rm sinalizador excluirá o contêiner assim que o comando do contêiner for encerrado.

finch run --rm public.ecr.aws/finch/hello-finch
public.ecr.aws/finch/hello-finch:latest:                                          resolved       |++++++++++++++++++++++++++++++++++++++|
index-sha256:a71e474da9ffd6ec3f8236dbf4ef807dd54531d6f05047edaeefa758f1b1bb7e:    done           |++++++++++++++++++++++++++++++++++++++|
manifest-sha256:705cac764e12bd6c5b0c35ee1c9208c6c5998b442587964b1e71c6f5ed3bbe46: done           |++++++++++++++++++++++++++++++++++++++|
config-sha256:6cc2bf972f32c6d16519d8916a3dbb3cdb6da97cc1b49565bbeeae9e2591cc60:   done           |++++++++++++++++++++++++++++++++++++++|
elapsed: 0.9 s                                                                    total:   0.0 B (0.0 B/s)

                            @@@@@@@@@@@@@@@@@@@
                        @@@@@@@@@@@@    @@@@@@@@@@@
                      @@@@@@@                  @@@@@@@
                    @@@@@@                        @@@@@@
                  @@@@@@                            @@@@@
                 @@@@@                      @@@#     @@@@@@@@@
                @@@@@                     @@   @@@       @@@@@@@@@@
                @@@@%                     @     @@            @@@@@@@@@@@
                @@@@                                               @@@@@@@@
                @@@@                                         @@@@@@@@@@@&
                @@@@@                                  &@@@@@@@@@@@
                 @@@@@                               @@@@@@@@
                  @@@@@                            @@@@@(
                   @@@@@@                        @@@@@@
                     @@@@@@@                  @@@@@@@
                        @@@@@@@@@@@@@@@@@@@@@@@@@@
                            @@@@@@@@@@@@@@@@@@


Hello from Finch!

Visit us @ github.com/runfinch

O Lima oferece suporte à emulação do espaço do usuário na máquina virtual subjacente. Embora todas as imagens que criamos e usamos no exemplo a seguir sejam imagens do Linux, a Lima VM está emulando a arquitetura da CPU do seu sistema host, que pode ser baseada em Intel ou Apple Silicon de 64 bits. Nos exemplos a seguir, mostraremos que não importa qual arquitetura de CPU seu sistema Mac usa, você pode criar, publicar e usar imagens para qualquer família de CPU. No exemplo a seguir, vamos criar uma imagem de arquitetura x86_64 em um laptop Apple Silicon, enviá-la para ECR e, em seguida, executá-la em um laptop Mac baseado em Intel.

Para verificar se estamos executando nossos comandos em um Mac baseado em Apple Silicon, podemos executar uname e veja a arquitetura listada como braço64:

uname -sm
Darwin arm64

Vamos criar e executar um amd64 recipiente usando o --platform opção para especificar a arquitetura não nativa:

finch run --rm --platform=linux/amd64 public.ecr.aws/amazonlinux/amazonlinux uname -sm
Linux x86_64

o --platform A opção também pode ser usada para compilações. Vamos criar um Dockerfile simples com duas linhas:

FROM public.ecr.aws/amazonlinux/amazonlinux:latest
LABEL maintainer="Chris Short"

Por padrão, o Finch criaria para a plataforma de arquitetura da CPU do host, que mostramos como arm64 acima. Em vez disso, vamos criar e enviar um contêiner amd64 para o ECR. Para construir uma imagem amd64, adicionamos o --platform flag ao nosso comando:

finch build --platform linux/amd64 -t public.ecr.aws/cbshort/finch-multiarch .
[+] Building 6.5s (6/6) FINISHED
 => [internal] load build definition from Dockerfile                                                                           0.1s
 => => transferring dockerfile: 142B                                                                                           0.0s
 => [internal] load .dockerignore                                                                                              0.1s
 => => transferring context: 2B                                                                                                0.0s
 => [internal] load metadata for public.ecr.aws/amazonlinux/amazonlinux:latest                                                 1.2s
 => [auth] aws:: amazonlinux/amazonlinux:pull token for public.ecr.aws                                                         0.0s
 => [1/1] FROM public.ecr.aws/amazonlinux/amazonlinux:[email protected]:d0cc2f24c888613be336379e7104a216c9aa881c74d6df15e30286f67  3.9s
 => => resolve public.ecr.aws/amazonlinux/amazonlinux:[email protected]:d0cc2f24c888613be336379e7104a216c9aa881c74d6df15e30286f67  0.0s
 => => sha256:e3cfe889ce0a44ace07ec174bd2a7e9022e493956fba0069812a53f81a6040e2 62.31MB / 62.31MB                               5.1s
 => exporting to oci image format                                                                                              5.2s
 => => exporting layers                                                                                                        0.0s
 => => exporting manifest sha256:af61210145ded93bf2234d63ac03baa24fe50e7187735f0849d8383bd5073652                              0.0s
 => => exporting config sha256:474c401eafe6b05f5a4b5b4128d7b0023f93c705e0328243501e5d6c7d1016a8                                0.0s
 => => sending tarball                                                                                                         1.3s
unpacking public.ecr.aws/cbshort/finch-multiarch:latest (sha256:af61210145ded93bf2234d63ac03baa24fe50e7187735f0849d8383bd5073652)...
Loaded image: public.ecr.aws/cbshort/finch-multiarch:latest%

finch push public.ecr.aws/cbshort/finch-multiarch
INFO[0000] pushing as a reduced-platform image (application/vnd.docker.distribution.manifest.v2+json, sha256:af61210145ded93bf2234d63ac03baa24fe50e7187735f0849d8383bd5073652)
manifest-sha256:af61210145ded93bf2234d63ac03baa24fe50e7187735f0849d8383bd5073652: done           |++++++++++++++++++++++++++++++++++++++|
config-sha256:474c401eafe6b05f5a4b5b4128d7b0023f93c705e0328243501e5d6c7d1016a8:   done           |++++++++++++++++++++++++++++++++++++++|
elapsed: 27.9s                                                                    total:  1.6 Ki (60.0 B/s)

Neste ponto, criamos uma imagem em um Mac baseado em Apple Silicon que pode ser usado em qualquer host Linux de arquitetura de CPU Intel/AMD com um tempo de execução de contêiner compatível com OCI. Pode ser uma instância EC2 de CPU Intel ou AMD, um Intel NUC local ou, como mostraremos a seguir, um Mac baseado em CPU Intel. Para mostrar esse recurso, executaremos nossa imagem recém-criada em um Mac baseado em Intel onde já temos o Finch instalado. Note que nós corremos uname aqui para mostrar a arquitetura deste Mac é x86_64que é análogo ao que a linguagem de programação Go referencia CPUs Intel/AMD de 64 bits como: amd64.

uname -a
Darwin wile.local 21.6.0 Darwin Kernel Version 21.6.0: Thu Sep 29 20:12:57 PDT 2022; root:xnu-8020.240.7~1/RELEASE_X86_64 x86_64

finch run --rm --platform linux/amd64 public.ecr.aws/cbshort/finch-multiarch:latest uname -a
public.ecr.aws/cbshort/finch-multiarch:latest:                                    resolved       |++++++++++++++++++++++++++++++++++++++|
manifest-sha256:af61210145ded93bf2234d63ac03baa24fe50e7187735f0849d8383bd5073652: done           |++++++++++++++++++++++++++++++++++++++|
config-sha256:474c401eafe6b05f5a4b5b4128d7b0023f93c705e0328243501e5d6c7d1016a8:   done           |++++++++++++++++++++++++++++++++++++++|
layer-sha256:e3cfe889ce0a44ace07ec174bd2a7e9022e493956fba0069812a53f81a6040e2:    done           |++++++++++++++++++++++++++++++++++++++|
elapsed: 9.2 s                                                                    total:  59.4 M (6.5 MiB/s)
Linux 73bead2f506b 5.17.5-300.fc36.x86_64 #1 SMP PREEMPT Thu Apr 28 15:51:30 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux

Você pode ver que os comandos e opções são familiares. Como Finch está passando nossos comandos para o cliente nerdctl, toda a sintaxe de comando e opções são as que você esperaria, e novos usuários podem consultar documentação do nerdctl.

Outro caso de uso é o teste de aplicativos de vários contêineres. vamos usar gritar como um aplicativo de exemplo que queremos executar localmente. O que é yelb? É um aplicativo da Web simples com cache, banco de dados, servidor de aplicativos e interface do usuário. Todos eles são executados como contêineres em uma rede que criaremos. Executaremos o yelb localmente para demonstrar os recursos de composição do Finch para microsserviços:

finch vm init
INFO[0000] Initializing and starting finch virtual machine...
INFO[0079] Finch virtual machine started successfully

finch compose up -d
INFO[0000] Creating network localtest_default
INFO[0000] Ensuring image redis:4.0.2
docker.io/library/redis:4.0.2:                                                    resolved       |++++++++++++++++++++++++++++++++++++++|
index-sha256:cd277716dbff2c0211c8366687d275d2b53112fecbf9d6c86e9853edb0900956:    done           |++++++++++++++++++++++++++++++++++++++|

[ snip ]

layer-sha256:afb6ec6fdc1c3ba04f7a56db32c5ff5ff38962dc4cd0ffdef5beaa0ce2eb77e2:    done           |++++++++++++++++++++++++++++++++++++++|
elapsed: 11.4s                                                                    total:  30.1 M (2.6 MiB/s)
INFO[0049] Creating container localtest_yelb-appserver_1
INFO[0049] Creating container localtest_redis-server_1
INFO[0049] Creating container localtest_yelb-db_1
INFO[0049] Creating container localtest_yelb-ui_1

A saída indica que uma rede foi criada, muitas imagens foram extraídas, iniciadas e agora estão todas em execução em nosso ambiente de teste local.

Neste caso de teste, estamos usando Yelb para descobrir onde uma pequena equipe deve almoçar. Compartilhamos a URL com nossa equipe, as pessoas votam e vemos o resultado por meio da IU:

captura de tela do voto Yelb

O que vem a seguir para Finch?

O projeto está apenas começando. A equipe trabalhará para adicionar recursos de forma iterativa e está ansiosa para ouvir sua opinião. Temos ideias para tornar a virtualização mais mínima, com tempos de inicialização mais rápidos para torná-la mais transparente para os usuários. Também estamos interessados ​​em tornar o Finch extensível, permitindo a funcionalidade complementar opcional. À medida que o projeto evolui, a equipe direcionará as contribuições para as dependências upstream, quando apropriado. Estamos entusiasmados em apoiar e contribuir para o sucesso de nossas principais dependências: nerdctl, containerd, BuildKit e Lima. Como mencionado anteriormente, uma das coisas interessantes sobre Finch é iluminar os projetos dos quais depende.

Por favor junte-se a nós! Iniciar uma discussão, abra um problema com novas ideias ou relate quaisquer bugs que encontrar, e estamos definitivamente interessados ​​em suas solicitações pull. Planejamos desenvolver o Finch em público, criando marcos e um roteiro com informações de nossos usuários e colaboradores. Também gostaríamos de receber feedback de vocês sobre suas experiências construindo e usando contêineres diariamente e como Finch pode ajudar!


Source link

Previous articleTestando Jogos PAGOS da Play Store 🤑
Next articleÉ hora de atualizar sua marca visual? (via @99designs) https://www.socialmediatoday.com/news/12-Visual-Trends-for-2023-Infographic/637104/

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Esse site utiliza o Akismet para reduzir spam. Aprenda como seus dados de comentários são processados.