Há um ano e meio, em 5 de março de 2018, o Google lançou a primeira versão alfa do seu projeto Open Source para CI / CD chamado
Skaffold , cujo objetivo era criar um "desenvolvimento simples e reproduzível para o Kubernetes" para que os desenvolvedores pudessem se concentrar no desenvolvimento e não na administração. O que pode ser de interesse para Skaffold? Como se viu, ele tem alguns trunfos na manga, graças aos quais ele pode se tornar uma ferramenta poderosa para um desenvolvedor e, talvez, um engenheiro operacional. Vamos nos familiarizar com o projeto e suas capacidades.
NB : A propósito, já conversamos brevemente sobre o Skaffold em nossa visão geral das ferramentas para desenvolvedores cuja vida está conectada ao Kubernetes.Teoria Objetivo e recursos
Portanto, de um modo geral, o Skaffold resolve o problema de automatizar o ciclo de CI / CD (nos estágios de criação, envio, implantação), oferecendo ao desenvolvedor um feedback imediato, ou seja, a capacidade de obter rapidamente o resultado das próximas alterações de código - na forma de um aplicativo atualizado em execução no cluster Kubernetes. E pode funcionar em diferentes contornos (dev, estágio, produção ...), para os quais o Skaffold ajuda a descrever os pipelines apropriados para a implantação.
O código fonte do Skaffold está escrito em Go e é distribuído sob a Apache License 2.0 (
GitHub ) gratuita.
Considere as principais funções e recursos. O primeiro inclui o seguinte:
- O Skaffold oferece ferramentas para a criação de pipelines de CI / CD.
- Permite monitorar alterações no código-fonte em segundo plano e iniciar o processo automatizado de criação de código em imagens de contêiner, publicando essas imagens no Docker Registry e implantando-as no cluster Kubernetes.
- Sincroniza arquivos no repositório com o diretório ativo no contêiner.
- Testa automaticamente usando o container-structure-test.
- Encaminha portas.
- Lê os logs do aplicativo em execução no contêiner.
- Ajuda na depuração de aplicativos escritos em Java, Node.js, Python, Go.
Agora, sobre os recursos:
- O Skaffold em si não possui componentes do lado do cluster . Ou seja, você não precisa configurar adicionalmente o Kubernetes para usar este utilitário.
- Pipelines diferentes para sua aplicação . Precisa distribuir o código no Minikube local enquanto estiver desenvolvendo e depois no palco ou na produção? Para isso, são fornecidos perfis e configurações do usuário, variáveis de ambiente e sinalizadores, que permitem descrever diferentes pipelines para um aplicativo.
- CLI Somente utilitário e configurações do console no YAML. Na rede, você pode encontrar referências a tentativas de criar uma GUI experimental , mas no momento isso provavelmente significa apenas que alguém precisa, mas não realmente.
- Modularidade . O Skaffold não é uma combinação independente, mas procura usar módulos separados ou soluções existentes para tarefas específicas.
Ilustração do último:
- Na fase de montagem, você pode usar:
- docker build localmente, em um cluster usando kaniko ou no Google Cloud Build;
- Bazel localmente;
- Jib Maven e Jib Gradle localmente ou no Google Cloud Build;
- scripts de construção personalizados executados localmente. Se você precisar executar outra solução (mais flexível / familiar / ...) para a montagem, ela será descrita no script para que o Skaffold a execute ( exemplo da documentação ). Isso permite que você use qualquer coletor que possa ser chamado usando um script;
- No estágio de teste, o já mencionado container-structure-test é suportado;
- Para implantação são fornecidos:
- Kubectl;
- Leme;
- personalizar.
Graças a isso, o Skaffold pode ser chamado de um tipo de
estrutura para a criação de CI / CD . Aqui está um exemplo de um fluxo de trabalho ao usá-lo (na documentação do projeto):
Como é o trabalho de Skaffold em geral?
- O utilitário monitora as alterações no diretório de origem. Se forem feitas modificações nos arquivos, elas serão sincronizadas com o pod de aplicativo no cluster Kubernetes. Se possível, sem remontar a imagem. Caso contrário, uma nova imagem será exibida.
- A imagem montada é verificada usando container-structure-test, marcada e enviada ao Docker Registry.
- Depois disso, a imagem é implantada - é implantada em um cluster Kubernetes.
- Se o lançamento foi inicializado usando o comando
skaffold dev , começamos a receber logs do aplicativo, e o Skaffold espera que as alterações repitam todas as etapas novamente.
Ilustração de marcos SkaffoldPrática. Tentando Skaffold
Para demonstrar o uso do Skaffold, darei um exemplo do
repositório GitHub do projeto . A propósito,
você pode encontrar muitos outros exemplos que levam em consideração várias especificidades. Todas as ações serão executadas localmente no Minikube. A instalação é simples e leva alguns minutos, e o kubectl é necessário para começar.
Instale o Skaffold:
curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64 chmod +x skaffold sudo mv skaffold /usr/local/bin skaffold version v0.37.1
Vamos clonar o repositório Skaffold com os exemplos necessários:
git clone https://github.com/GoogleContainerTools/skaffold cd skaffold/examples/microservices
Eu escolhi um exemplo com dois pods, cada um dos quais contém um pequeno aplicativo no Go. Um aplicativo é o frontend (leeroy-web), uma solicitação de redirecionamento para o segundo aplicativo é o backend (leeroy-app). Vamos ver como fica:
~/skaffold/examples/microservices
leeroy-app e leeroy-web contêm o código Go e Dockerfiles simples para criar este código localmente:
~/skaffold/examples/microservices
Não darei o código do aplicativo - é suficiente saber que o
leeroy-web aceita solicitações e os
leeroy-app como proxy para o
leeroy-app . Portanto, nos arquivos
Deployment.yaml há Serviço apenas para o
app (para roteamento interno). A porta do
web pod será lançada para nós para acesso rápido ao aplicativo.
Como é o
skaffold.yaml :
~/skaffold/examples/microservices # cat skaffold.yaml apiVersion: skaffold/v1beta13 kind: Config build: artifacts: - image: leeroy-web context: ./leeroy-web/ - image: leeroy-app context: ./leeroy-app/ deploy: kubectl: manifests: - ./leeroy-web/kubernetes/* - ./leeroy-app/kubernetes/* portForward: - resourceType: deployment resourceName: leeroy-web port: 8080 localPort: 9000
Todas as etapas mencionadas acima são descritas aqui. Além dessa configuração, há também um arquivo com configurações globais -
~/.skaffold/config . Pode ser editado manualmente ou por meio da CLI - por exemplo, assim:
skaffold config set --global local-cluster true
Este comando define a variável global do
local-cluster como
true , após o que o Skaffold não tentará 'enviar' as imagens para o registro remoto. Se você estiver desenvolvendo localmente, poderá usar este comando para adicionar imagens localmente também.
Voltar para
skaffold.yaml :
- No estágio de
build , indicamos que você precisa coletar e salvar a imagem localmente. Após o início da montagem, veremos o seguinte:
// .. Minikube , // ,
Como você pode ver, Skaffold testou independentemente as imagens. A propósito, várias políticas de marcação são suportadas. - O seguinte é especificado no
context: ./leeroy-app/ configuração context: ./leeroy-app/ , ou seja, O contexto em que a imagem é montada é especificado. - No estágio de implantação, é determinado que usaremos o kubectl e uma máscara para os manifestos desejados.
PortForward : semelhante à maneira como geralmente encaminhamos portas usando o kubectl port-forward , forneça ao Skaffold instruções para chamar esse comando. Nesse caso, a porta local 9000 é encaminhada para 8080 em Implantação com o nome leeroy-web .
É hora de começar o desenvolvimento
skaffold dev : a equipe criará um "loop de feedback" contínuo, ou seja, não apenas coleta tudo e instala em um cluster, mas também informa sobre o estado dos pods no momento, monitorará as alterações e atualizará o estado dos pods.
Aqui está o resultado da execução do
skaffold dev --port-forward ao remontar:
Em primeiro lugar, fica claro que o cache está sendo usado. Próximo - o aplicativo é montado, implantado, as portas são encaminhadas. Como
--port-forward é especificado, Skaffold encaminhou a porta para a
web , conforme solicitado, mas encaminhou o
app a seu critério (escolha o mais próximo gratuito). Depois disso, obtemos os primeiros logs dos aplicativos.
Verificar desempenho?
~/skaffold/examples/microservices
Modifique o
leeroy-app/app.go - leva alguns segundos ... e:
~/skaffold/examples/microservices
Ao mesmo tempo, o próprio Skaffold trouxe para o console a mesma coisa que antes, com exceção de um ponto: lançou apenas o
leeroy-app , e não todos de uma vez.
Mais prática
Vale ressaltar que, ao criar um novo projeto, as configurações do Skaffold podem ser inicializadas usando o comando
init , o que é muito conveniente. Além disso, você pode escrever várias configurações: desenvolva na configuração padrão e depois role para o estágio com o comando
run (o mesmo processo que o
dev , apenas não segue as alterações), usando uma configuração diferente.
Katacoda tem um
tutorial com um exemplo ainda mais simples. Mas oferece uma caixa de areia pronta com o Kubernetes, o aplicativo e o Skaffold. Uma ótima opção se você estiver interessado em experimentar o básico por conta própria.
Um possível caso de uso do Skaffold é realizar o desenvolvimento em um cluster remoto. Nem todo mundo se sente confortável executando o Minikube em seu próprio hardware e, em seguida, implementando o aplicativo e aguardando seu bom funcionamento ... Nesse caso, o Skaffold resolve perfeitamente a tarefa que, por exemplo, os engenheiros do Reddit podem confirmar, como já
escrevemos em nosso blog.
E
nesta publicação da Weaveworks, você pode encontrar um exemplo de criação de um pipeline para produção.
Conclusão
O Skaffold é uma ferramenta conveniente para a construção de pipelines que envolvem a implantação de aplicativos no Kubernetes e são focadas principalmente nas necessidades de desenvolvimento. Com isso, é bastante simples criar um pipeline "curto" que leve em consideração as necessidades básicas do desenvolvedor; no entanto, se desejar, você poderá organizar processos maiores. Como um dos exemplos ilustrativos do uso do Skaffold nos processos de CI / CD
, é fornecido um
projeto de
teste de 10 microsserviços usando os recursos do Kubernetes, gRPC, Istio e OpenCensus Tracing.
O Skaffold já recebeu quase mais de 8000 estrelas no GitHub, está sendo desenvolvido pelo Google e faz parte do
GoogleContainerTools - em geral, no momento, há todos os motivos para acreditar que o projeto se desenvolverá para sempre.
PS
Leia também em nosso blog: