Información sobre Skaffold

1. Objetivos

Skaffold es una herramienta que controla el flujo de trabajo para compilar, enviar e implementar tu aplicación. Puedes usar Skaffold para configurar fácilmente un espacio de trabajo de desarrollo local, optimizar tu bucle de desarrollo interno y realizar integraciones con otras herramientas, como Kustomize y Helm, para ayudarte a administrar tus manifiestos de Kubernetes.

En este instructivo, trabajarás con algunos conceptos básicos de Skaffold, lo usarás para automatizar tu bucle de desarrollo interno y, luego, implementarás una aplicación.

Harás lo siguiente:

  • Configura y habilita Skaffold para el desarrollo local
  • Compila y ejecuta una aplicación simple en Go
  • Administra la implementación de aplicaciones locales con Skaffold
  • Renderiza manifiestos e implementa tu aplicación

2. Antes de comenzar

Prepara tu espacio de trabajo

  1. Visita la siguiente URL para abrir el editor de Cloud Shell:
https://shell.cloud.google.com

Permite las cookies de terceros. Haz clic en "El sitio no funciona" y, luego, en "Permitir cookies".

7b702066a2135a3d.png

3394f82132eb4fd4.png

  1. Si aún no lo has hecho, clona el código fuente de la aplicación en la ventana de la terminal con el siguiente comando:
git clone https://github.com/GoogleCloudPlatform/software-delivery-workshop.git
  1. Cambia al directorio del repositorio clonado:
cd software-delivery-workshop/labs/understanding-skaffold/getting-started
  1. Ejecuta el siguiente comando para configurar tu espacio de trabajo de Cloud Shell en el directorio actual:
cloudshell workspace .

Prepara tu proyecto

  1. Para asegurarte de que tu proyecto de Google Cloud esté configurado correctamente, ejecuta el siguiente comando:
gcloud config set project {{project-id}}

3. Primeros pasos con Skaffold

  1. Ejecuta el siguiente comando para crear el archivo de configuración de Skaffold de nivel superior, skaffold.yaml:
cat <<EOF > skaffold.yaml
apiVersion: skaffold/v2beta21
kind: Config
metadata:
  name: getting-started-kustomize
build:
  tagPolicy:
    gitCommit:
      ignoreChanges: true
  artifacts:
  - image: skaffold-kustomize
    context: app
    docker:
      dockerfile: Dockerfile
deploy:
  kustomize:
    paths:
    - overlays/dev
profiles:
- name: staging
  deploy:
    kustomize:
      paths:
      - overlays/staging
- name: prod
  deploy:
    kustomize:
      paths:
      - overlays/prod
EOF
  1. Abre el archivo skaffold.yaml en el panel del IDE. Este es el archivo de configuración de nivel superior que define la canalización de Skaffold.

Observa el formato YAML similar a Kubernetes y las siguientes secciones en el archivo YAML:

  • build
  • deploy
  • profiles

En estas secciones, se define cómo se debe compilar e implementar la aplicación, así como los perfiles para cada destino de implementación.

Puedes obtener más información sobre la lista completa de etapas de Skaffold en la documentación de Skaffold Pipeline Stages.

4. Compilación

La sección build contiene la configuración que define cómo se debe compilar la aplicación. En este caso, puedes ver la configuración sobre cómo se deben controlar las etiquetas git, así como una sección artifacts que define las imágenes de contenedor que componen la aplicación.

Además, en esta sección, puedes ver la referencia al objeto Dockerfile que se usará para compilar las imágenes. Además, Skaffold admite otras herramientas de compilación, como Jib, Maven, Gradle, Buildpacks nativo de la nube, Bazel y secuencias de comandos personalizadas. Puedes obtener más información sobre esta configuración en la documentación de Skaffold Build.

5. Implementar

La sección deploy contiene la configuración que define cómo se debe implementar la aplicación. En este caso, puedes ver un ejemplo de una implementación predeterminada que configura Skaffold para usar la herramienta Kustomize.

La herramienta Kustomize proporciona funcionalidad para generar manifiestos de Kubernetes combinando un conjunto de archivos YAML de componentes comunes (en el directorio base) con una o más "superposiciones" que suelen corresponder a uno o más destinos de implementación, por lo general, dev, test, staging y production o similares.

En este ejemplo, puedes ver dos anulaciones para tres destinos: dev, staging y prod. La anulación dev se usará durante el desarrollo local, y las anulaciones staging y prod, cuando se realice la implementación con Skaffold.

6. Perfiles

La sección profiles contiene la configuración que define las configuraciones de compilación, prueba e implementación para diferentes contextos. Por lo general, los diferentes contextos son diferentes entornos en la canalización de implementación de tu aplicación, como staging o prod en este ejemplo. Esto significa que puedes administrar fácilmente manifiestos cuyo contenido debe ser diferente para los distintos entornos de destino, sin repetir la configuración estándar.

La configuración de la sección profiles puede reemplazar o parchear cualquier elemento de la configuración principal (es decir, las secciones build, test o deploy, por ejemplo).

Como ejemplo, abre el archivo overlays > prod > deployment.yaml. Observa que la cantidad de réplicas de la aplicación está configurada aquí en tres, lo que anula la configuración base.

  1. Abre el siguiente archivo app > main.go en el panel del IDE. Esta es una aplicación simple de Go que escribe una cadena en stdout cada segundo.
  2. Observa que la aplicación también genera el nombre del pod de Kubernetes en el que se ejecuta.

Cómo ver el Dockerfile

  1. Abre el archivo app > Dockerfile en el panel del IDE. Este archivo contiene una secuencia de directivas para compilar la imagen del contenedor de la aplicación para el archivo main.go y se hace referencia a él en el archivo skaffold.yaml de nivel superior.

7. Desarrolla con Skaffold

Configura tu entorno de Kubernetes

  1. Ejecuta el siguiente comando para asegurarte de que tu clúster de Kubernetes local se esté ejecutando y esté configurado:
minikube start

Este proceso puede tardar varios minutos. Si el clúster se inició correctamente, deberías ver el siguiente resultado:

Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default
  1. Ejecuta el siguiente comando para crear espacios de nombres de Kubernetes para dev, staging y prod:
kubectl apply -f namespaces.yaml

Deberías ver el siguiente resultado:

namespace/dev created
namespace/staging created
namespace/prod created

Usa Skaffold para el desarrollo local

  1. Ejecuta el siguiente comando para compilar la aplicación y, luego, implementarla en un clúster de Kubernetes local que se ejecuta en Cloud Shell:
skaffold dev

Deberías ver que se ejecuta el proceso de compilación del contenedor de la aplicación, que puede tardar un minuto, y, luego, el resultado de la aplicación que se repite cada segundo:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-dev-xxxxxxxxx-xxxxx

Ten en cuenta que el nombre exacto del pod variará con respecto al resultado genérico que se mostró anteriormente.

Realiza cambios en la aplicación

Ahora que la aplicación se ejecuta en tu clúster local de Kubernetes, puedes realizar cambios en el código, y Skaffold volverá a compilar y a volver a implementar la aplicación en el clúster automáticamente.

  1. Abre el archivo app > main.go en el panel del IDE y cambia la cadena de salida:
"Hello world from pod %s!\n"

para:

"Hello Skaffold world from pod %s!\n"

Cuando realices el cambio, deberías ver que Skaffold vuelve a compilar la imagen y la vuelve a implementar en el clúster, con el cambio en el resultado visible en la ventana de la terminal.

  1. Ahora, también en el archivo "app > main.go" del panel del IDE, cambia la línea:
time.Sleep(time.Second * 1)

a

time.Sleep(time.Second * 10)

Una vez más, deberías ver que la aplicación se vuelve a compilar y se vuelve a implementar, con la línea de salida que aparece una vez cada 10 segundos.

Cómo realizar cambios en la configuración de Kubernetes

A continuación, realizarás un cambio en la configuración de Kubernetes y, una vez más, Skaffold volverá a implementar automáticamente.

  1. Abre el archivo base > deployment.yaml en el IDE y cambia la línea:
replicas: 1

a

replicas: 2

Una vez que se vuelva a implementar la aplicación, deberías ver dos Pods en ejecución, cada uno con un nombre diferente.

  1. Ahora, vuelve a cambiar la misma línea en el archivo base > deployment.yaml a lo siguiente:
replicas: 1

Deberías ver que se quitó uno de los Pods del servicio, por lo que solo quedará uno.

  1. Por último, presiona Ctrl-C en la ventana de la terminal para detener el desarrollo local de Skaffold.

Cómo cortar una versión

A continuación, crearás una versión compilando una imagen de versión y, luego, la implementarás en un clúster.

  1. Ejecuta el siguiente comando para compilar la versión:
skaffold build --file-output artifacts.json

Este comando compilará la imagen final (si es necesario) y generará los detalles de la versión en el archivo artifacts.json.

Si quisieras usar una herramienta como Cloud Deploy para realizar implementaciones en tus clústeres, este archivo contendría la información de la versión. Esto significa que los artefactos son inmutables en la ruta hacia la publicación.

  1. Ejecuta el siguiente comando para ver el contenido del archivo artifacts.json:
cat artifacts.json | jq

Ten en cuenta que el archivo contiene la referencia a la imagen que se usará en la implementación final.

Implementación en la etapa de pruebas

  1. Ejecuta el siguiente comando para implementar la versión con el perfil staging:
skaffold deploy --profile staging --build-artifacts artifacts.json --tail

Una vez que se complete la implementación, deberías ver el resultado de dos Pods similar al siguiente:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-staging-xxxxxxxxxx-xxxxx!
  1. Presiona Ctrl + C en la ventana de la terminal para detener la salida de Skaffold.
  2. Ejecuta el siguiente comando para observar tu aplicación en funcionamiento en el clúster:
kubectl get all --namespace staging

Deberías ver dos nombres de Pods distintos, ya que el perfil staging de la aplicación especifica que debe haber dos réplicas en la implementación.

Cómo implementar para producción

  1. Ahora, ejecuta el siguiente comando para implementar la versión con el perfil prod:
skaffold deploy --profile prod --build-artifacts artifacts.json --tail

Una vez que se complete la implementación, deberías ver el resultado de tres Pods similar al siguiente:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-prod-xxxxxxxxxx-xxxxx!
  1. Presiona Ctrl + C en la ventana de la terminal para detener la salida de Skaffold.

Deberías ver tres nombres de Pods distintos, ya que el perfil prod de la aplicación especifica que debe haber tres réplicas en la implementación.

  1. Ejecuta el siguiente comando para observar tu aplicación en funcionamiento en el clúster:
kubectl get all --namespace prod

Deberías ver un resultado que contenga líneas similares a las siguientes, que muestran la implementación de producción:

NAME                                      READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/skaffold-kustomize-prod   3/3     3            3           16m

También deberías ver tres Pods de aplicación en ejecución.

NAME                                           READY   STATUS    RESTARTS   AGE
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m

8. ¡Felicitaciones!

¡Felicitaciones! Completaste el lab de Understanding Skaffold y aprendiste a configurar y usar Skaffold para el desarrollo local y la implementación de aplicaciones.

Pasos siguientes:

Sigue aprendiendo sobre Skaffold:

Limpieza

  1. Ejecuta el siguiente comando para apagar el clúster local:
minikube delete