Revisión de Skaffold para o desenvolvemento de Kubernetes

Hai ano e medio, o 5 de marzo de 2018, Google lanzou a primeira versión alfa do seu proxecto de código aberto para CI/CD chamado Patín, cuxo obxectivo era crear "desenvolvemento de Kubernetes sinxelo e repetible" para que os desenvolvedores puidesen centrarse no desenvolvemento e non na administración. Que pode ser interesante de Skaffold? Polo que se ve, ten algúns trucos baixo a manga que poden converterse nunha ferramenta poderosa para o programador, e quizais mesmo para o enxeñeiro de operacións. Coñecemos o proxecto e as súas capacidades.

NB: Por certo, xa falamos brevemente de Skaffold no noso xeral revisión de ferramentas de desenvolvedores, cuxas vidas están conectadas con Kubernetes.

Teoría. Finalidade e capacidades

Entón, en xeral, Skaffold resolve o problema de automatizar o ciclo CI/CD (nas fases de construción, inserción e implantación), ofrecendo ao desenvolvedor comentarios rápidos, é dicir. a capacidade de recibir rapidamente o resultado dos cambios de código posteriores, en forma dunha aplicación actualizada que se executa no clúster de Kubernetes. E pode funcionar en diferentes circuítos (dev, stage, production...), para o que Skaffold axuda a describir as correspondentes canalizacións para o lanzamento.

O código fonte de Skaffold está escrito en Go, distribuído por baixo a licenza gratuíta de Apache 2.0 (GitHub).

Vexamos as principais funcións e características. Os primeiros inclúen os seguintes:

• Skaffold ofrece ferramentas para crear canalizacións CI/CD.
• Permítelle supervisar os cambios no código fonte en segundo plano e executar un proceso automatizado de ensamblaxe de código en imaxes de contedores, publicando estas imaxes no Rexistro de Docker e despregándoas no clúster de Kubernetes.
• Sincroniza os ficheiros do repositorio co directorio de traballo do contedor.
• Proba automaticamente usando container-structure-test.
• Portos de reenvío.
• Le os rexistros dunha aplicación en execución nun contedor.
• Axuda na depuración de aplicacións escritas en Java, Node.js, Python, Go.

Agora sobre as características:

• O propio Skaffold non ten compoñentes do clúster. É dicir, non hai que configurar máis Kubernetes para usar esta utilidade.
• Diferentes canalizacións para a súa aplicación. Necesitas lanzar o código ao Minikube local mentres estás a desenvolver e, a continuación, poñerlo en escena ou na produción? Para este fin existen perfís e configuracións de usuario, variables de ambiente e marcas, que permiten describir diferentes canalizacións para unha aplicación.
• CLI. Só a utilidade da consola e as configuracións en YAML. En Internet podes atopar referencias a intentos de creación GUI experimental, con todo, polo momento, o máis probable é que isto signifique que alguén o necesita, pero non realmente.
• Modularidade. Skaffold non é unha colleitadora autónoma, senón que se esforza por utilizar módulos individuais ou solucións existentes para tarefas específicas.

Ilustración deste último:

• Na fase de montaxe pode usar:
  • docker build localmente, nun clúster usando kaniko ou en Google Cloud Build;
  • Bazel localmente;
  • Jib Maven e Jib Gradle localmente ou en Google Cloud Build;
  • scripts de compilación personalizados executados localmente. Se precisa executar outra solución de compilación (máis flexible/familiar/...), descríbese no script para que Skaffold a inicie (exemplo da documentación). Isto permítelle usar calquera colector que se poida chamar mediante un script;
• Na fase de proba, o xa mencionado proba-estrutura-contedor;
• Para a implantación ofrécense o seguinte:
  • Kubectl;
  • Helmo;
  • personalizar.

Grazas a isto, Skaffold pódese chamar un único marco para construir CI/CD. Aquí tes un exemplo de fluxo de traballo cando o usas (a partir da documentación do proxecto):

Como é o traballo de Skaffold en termos xerais?

1. A utilidade supervisa os cambios no directorio do código fonte. Se se realizan modificacións nos ficheiros, sincronizaranse co pod da aplicación no clúster de Kubernetes. Se é posible, sen volver montar a imaxe. En caso contrario, recoméndase unha nova imaxe.
2. A imaxe ensamblada compróbase mediante container-structure-test, etiquetárase e envíase ao Rexistro Docker.
3. Despois diso, a imaxe é despregada - despregada no clúster de Kubernetes.
4. Se o lanzamento foi inicializado usando o comando skaffold dev, entón comezamos a recibir rexistros da aplicación e Skaffold agarda os cambios para repetir todas as accións de novo.

Ilustración das principais etapas do funcionamento do Skaffold

Práctica. Probando Skaffold

Para demostrar o uso de Skaffold, vou tomar un exemplo de Repositorio do proxecto GitHub... Por certo, no mesmo lugar Podes atopar moitos outros exemplos que teñan en conta varios aspectos específicos. Realizarei todas as accións localmente en Minikube. A instalación é sinxela e leva uns minutos, e necesitarás kubectl para comezar.

Instalar 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

Imos clonar o repositorio de Skaffold cos exemplos necesarios:

git clone https://github.com/GoogleContainerTools/skaffold
cd skaffold/examples/microservices

Escollín un exemplo con dous pods, cada un contén unha pequena aplicación Go. Unha aplicación é o frontend (leeroy-web), que redirixe a solicitude á segunda aplicación, o backend (leeroy-app). Vexamos como se ve:

~/skaffold/examples/microservices # tree
.
├── leeroy-app
│   ├── app.go
│   ├── Dockerfile
│   └── kubernetes
│       └── deployment.yaml
├── leeroy-web
│   ├── Dockerfile
│   ├── kubernetes
│   │   └── deployment.yaml
│   └── web.go
├── README.adoc
└── skaffold.yaml
 
4 directories, 8 files

leeroy-app e leeroy-web conteñen código Go e ficheiros Dockerfile simples para crear este código localmente:

~/skaffold/examples/microservices # cat leeroy-app/Dockerfile
FROM golang:1.12.9-alpine3.10 as builder
COPY app.go .
RUN go build -o /app .
 
FROM alpine:3.10
CMD ["./app"]
COPY --from=builder /app .

Non vou dar o código da aplicación, é suficiente para saber iso leeroy-web acepta solicitudes e as envía apoderados leeroy-app. Polo tanto nos arquivos Deployment.yaml hai un servizo só para app (para enrutamento interno). Porto de pod web reenviarémolo a nós mesmos para acceder rapidamente á aplicación.

Parece 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

Aquí descríbense todas as etapas mencionadas anteriormente. Ademais desta configuración, tamén hai un ficheiro con configuración global - ~/.skaffold/config. Pódese editar manualmente ou a través da CLI, por exemplo, así:

skaffold config set --global local-cluster true

Este comando establecerá a variable global local-cluster en significado true, despois de que Skaffold non tentará enviar imaxes ao rexistro remoto. Se está a desenvolver localmente, pode usar este comando para crear imaxes localmente.

Voltar skaffold.yaml:

• No escenario build especificamos que cómpre recoller e gardar a imaxe localmente. Despois de que se execute a compilación por primeira vez, veremos o seguinte:

  // т.к. Minikube создает кластер в отдельной виртуальной машине,
  // придется проникнуть внутрь, чтобы найти образы
  # minikube ssh
  $ docker images
  REPOSITORY                                TAG                                                                IMAGE ID            CREATED             SIZE 
  leeroy-app                                7d55a50803590b2ff62e47e6f240723451f3ef6f8c89aeb83b34e661aa287d2e   7d55a5080359        4 hours ago         13MB 
  leeroy-app                                v0.37.1-171-g0270a0c-dirty                                         7d55a5080359        4 hours ago         13MB
  leeroy-web                                5063bfb29d984db1ff70661f17d6efcc5537f2bbe6aa6907004ad1ab38879681   5063bfb29d98        5 hours ago         13.1MB
  leeroy-web                                v0.37.1-171-g0270a0c-dirty                                         5063bfb29d98        5 hours ago         13.1MB

  Como podes ver, Skaffold etiquetou as imaxes. Por certo, son compatibles varias políticas de etiquetado.

• Máis adiante na configuración indícase context: ./leeroy-app/, é dicir. especifícase o contexto no que se recolle a imaxe.
• Na fase de implantación, determínase que usaremos kubectl e unha máscara para os manifestos necesarios.
• PortForward: semellante ao que adoitamos usar os portos kubectl port-forward, damos instrucións a Skaffold para chamar a este comando. Neste caso, o porto local 9000 envíase a 8080 en Implementación co nome leeroy-web.

É hora de lanzar skaffold dev: O equipo creará un "bucle de retroalimentación" en curso, é dicir. non só recollerá todo e o despregará no clúster, senón que tamén che informará sobre o estado dos pods neste momento, supervisará os cambios e actualizará o estado dos pods.

Velaquí o resultado do lanzamento skaffold dev --port-forward ao volver a montar:

En primeiro lugar, podes ver que se está a usar a caché. A continuación, a aplicación é montada, despregada e os portos envíanse. Dende que se especifica --port-forward, Skaffold enviou o porto a web, como lle preguntaron, pero app lanzou ao seu criterio (elixiu o libre máis próximo). Despois diso, recibimos os primeiros rexistros das aplicacións.

Imos comprobar se funciona?

~/skaffold/examples/microservices # kubectl get po
NAME                          READY   STATUS    RESTARTS   AGE
leeroy-app-6998dfcc95-2nxvf   1/1     Running   0          103s
leeroy-web-69f7d47c9d-5ff77   1/1     Running   0          103s
~/skaffold/examples/microservices # curl localhost:9000
leeroooooy app!!!

Modificando o ficheiro leeroy-app/app.go - Pasan uns segundos... e:

~/skaffold/examples/microservices # kubectl get po
NAME                          READY   STATUS    RESTARTS   AGE
leeroy-app-ffd79d986-l6nwp    1/1     Running   0          11s
leeroy-web-69f7d47c9d-5ff77   1/1     Running   0          4m59s
~/skaffold/examples/microservices # curl localhost:9000
leeroooooy Habr!!!

Ao mesmo tempo, o propio Skaffold mostraba o mesmo na consola que antes, coa excepción dun punto: só se lanzou leeroy-app, e non todos á vez.

Máis práctica

Tamén vale a pena mencionar que ao crear un novo proxecto, as configuracións de Skaffold pódense arrancar usando o comando init, que é moi cómodo. Ademais, pode escribir varias configuracións: levar a cabo o desenvolvemento da configuración predeterminada e, a continuación, lanzar ao escenario co comando run (mesmo proceso que dev, simplemente non supervisa os cambios), usando unha configuración diferente.

En katacoda hai liderado É aínda máis fácil cun exemplo. Pero ofrece un sandbox preparado con Kubernetes, unha aplicación e Skaffold. Unha excelente opción se estás interesado en probar o básico.

Un posible caso de uso para Skaffold é realizar o desenvolvemento nun clúster remoto. Non todos se senten cómodos executando Minikube no seu propio hardware, para despois lanzar a aplicación e esperar que funcione adecuadamente... Neste caso, Skaffold resolve o problema á perfección, o que pode ser confirmado, por exemplo, polos enxeñeiros de Reddit, como temos xa comentado писали no noso blog.

E en esta publicación de Weaveworks podes atopar un exemplo de creación dunha canalización para a produción.

Conclusión

Skaffold é unha ferramenta conveniente para crear canalizacións que impliquen o lanzamento de aplicacións en Kubernetes e que se centran principalmente nas necesidades de desenvolvemento. Facilita a creación dunha canalización "curta" que teña en conta as necesidades básicas do programador, pero se o desexa, pode organizar procesos máis grandes. Como un dos claros exemplos de uso de Skaffold nos procesos CI/CD dase tal proxecto de proba de 10 microservizos utilizando as capacidades de Kubernetes, gRPC, Istio e OpenCensus Tracing.

Skaffold xa ten case máis de 8000 estrelas en GitHub, está desenvolvido por Google e forma parte de Google ContainerTools — en xeral, polo momento hai motivos para crer que o proxecto se desenvolverá feliz para sempre.

PS

Lea tamén no noso blog:

• «Ferramentas para desenvolvedores de aplicacións que se executan en Kubernetes»;
• «werf - a nosa ferramenta para CI / CD en Kubernetes (descrición xeral e informe de vídeo)»;
• «Garden v0.10.0: o teu portátil non necesita Kubernetes»;
• «Consellos e trucos de Kubernetes: sobre o desenvolvemento local e a telepresencia».

Fonte: www.habr.com