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 lugar de trabajo de desarrollo local, optimizar tu ciclo de desarrollo interno y realizar integraciones con otras herramientas, como Kustomize y Helm, para 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 golang simple
  • Administra la implementación de aplicaciones locales con Skaffold
  • Renderiza manifiestos y, luego, implementa tu aplicación

2. Antes de comenzar

Prepara tu lugar de trabajo

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

Permite 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 la 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 establecer tu lugar de trabajo de Cloud Shell en el directorio actual:
cloudshell workspace .

Prepara tu proyecto

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

3. Cómo comenzar a usar 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 YAML:

  • build
  • deploy
  • profiles

En estas secciones, se define cómo se debe compilar y, luego, 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 las etapas de la canalización de Skaffold.

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 de 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 de esto, en esta sección, puedes ver la referencia a 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, por lo general, corresponden 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 superposiciones para tres destinos: dev, staging y prod. La superposición dev se usará durante el desarrollo local y las superposiciones staging y prod para cuando se implemente 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 diferir para diferentes entornos de destino, sin repetir la configuración del modelo de texto.

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).

Por ejemplo, abre el archivo overlays > prod > deployment.yaml. Observa que la cantidad de réplicas para la aplicación se configura aquí para que sea 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 golang simple que escribe una cadena en stdout cada segundo.
  2. Observa que la aplicación también muestra 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 este en el archivo skaffold.yaml de nivel superior.

7. Cómo desarrollar con Skaffold

Cómo configurar 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

Esto puede tardar varios minutos. Deberías ver el siguiente resultado si el clúster se inició correctamente:

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, lo que puede tardar un minuto, y, luego, el resultado de la aplicación 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á del resultado genérico que se indicó anteriormente.

Cómo realizar 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 implementar automáticamente la aplicación en el clúster.

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

a:

"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, y el cambio en el resultado se puede ver en la ventana de la terminal.

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

to

time.Sleep(time.Second * 10)

Deberías ver que la aplicación se volvió a compilar e implementar, y la línea de resultados debería aparecer 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

to

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 del archivo base > deployment.yaml a lo siguiente:
replicas: 1

Deberías ver que se quitó uno de los pods del servicio, de modo que solo quede 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 la versión y, luego, implementándola 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 deseas usar una herramienta como Cloud Deploy para implementar en tus clústeres, este archivo contiene 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

Cuando se complete la implementación, deberías ver un 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 el resultado de Skaffold.
  2. Ejecuta el siguiente comando para observar que tu aplicación se está ejecutando 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 un 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 el resultado de Skaffold.

Deberías ver tres nombres de Pod 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 que tu aplicación se está ejecutando 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 Understanding Skaffold y aprendiste a configurar y usar Skaffold para el desarrollo local y la implementación de aplicaciones.

¿Qué sigue?

Obtén más información sobre Skaffold:

Limpieza

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