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 , 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 , 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, 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 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 , 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 (). Isto permítelle usar calquera colector que se poida chamar mediante un script;
- Na fase de proba, o xa mencionado ;
- 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?
- 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.
- A imaxe ensamblada compróbase mediante container-structure-test, etiquetárase e envíase ao Rexistro Docker.
- Despois diso, a imaxe é despregada - despregada no clúster de Kubernetes.
- 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 ... Por certo, 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.1Imos clonar o repositorio de Skaffold cos exemplos necesarios:
git clone https://github.com/GoogleContainerTools/skaffold
cd skaffold/examples/microservicesEscollí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 filesleeroy-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
buildespecificamos 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.1MBComo 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 portoskubectl 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 nomeleeroy-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 É 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 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 tal 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 — en xeral, polo momento hai motivos para crer que o proxecto se desenvolverá feliz para sempre.
PS
Lea tamén no noso blog:
- «»;
- «»;
- «»;
- «».
Fonte: www.habr.com