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 bucle de desarrollo interno y, además, integrarlo a otras herramientas como Kustomize y Helm para administrar los manifiestos de Kubernetes.

En este instructivo, aprenderás 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 local de aplicaciones con Skaffold
  • Renderiza manifiestos e implementa tu aplicación

2. Antes de comenzar

Preparando tu espacio 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 "Sitio que no funciona". y luego "Permitir cookies".

7b702066a2135a3d.png

3394f82132eb4fd4.png

  1. Si aún no lo has hecho, en la ventana de la terminal clona el código fuente de la aplicación 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 de forma correcta:
gcloud config set project {{project-id}}

3. Comienza 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 YAML:

  • build
  • deploy
  • profiles

En estas secciones, se define cómo se debe compilar e implementar la aplicación, además de 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 Etapas de 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 manejar las etiquetas git, así como una sección artifacts que define las imágenes de contenedor que conforman 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 es compatible con otras herramientas de compilación, como Jib, Maven, Gradle, Buildpacks y Bazel nativas de la nube, y secuencias de comandos personalizadas. Puedes obtener más información sobre esta configuración en la documentación de compilación de Skaffold.

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

En la sección profiles, se definen las configuraciones de compilación, implementación y prueba para diferentes contextos. Los diferentes contextos suelen ser entornos distintos 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 en los distintos entornos de destino, sin necesidad de repetir la configuración estándar.

La configuración de la sección profiles puede reemplazar o aplicar parches a 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 de golang simple que escribe una string en stdout por segundo.
  2. Observa que la aplicación también genera el nombre del Pod de Kubernetes en el cual se ejecuta.

Visualiza 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. Desarrolla con Skaffold

Configura tu entorno de Kubernetes

  1. Ejecuta el siguiente comando para asegurarte de que tu clúster de Kubernetes local esté en ejecución y 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 a fin de 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 local de Kubernetes que se ejecute 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 que 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á respecto del resultado genérico proporcionado arriba.

Realiza cambios en la aplicación

Ahora que la aplicación se está ejecutando en tu clúster local de Kubernetes, puedes realizar cambios en el código, y Skaffold volverá a compilar y a implementar la aplicación automáticamente 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 hayas realizado el cambio, deberías ver que Skaffold vuelve a compilar la imagen y la vuelve a implementar en el clúster. El cambio en el resultado debería verse en la ventana de la terminal.

  1. Además, en el archivo "app > main.go&quot; En el panel del IDE, cambia la línea:
time.Sleep(time.Second * 1)

para

time.Sleep(time.Second * 10)

Deberías ver que la aplicación se vuelve a compilar y a implementar, y la línea de resultados aparece una vez cada 10 segundos.

Realiza 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 se volverá a implementar automáticamente.

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

para

replicas: 2

Una vez que la aplicación se haya vuelto a implementar, 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:
replicas: 1

Deberías ver que uno de los Pods se quitó del servicio para que solo quede uno.

  1. Por último, presiona Ctrl-C en la ventana de 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

Con este comando, se compilará la imagen final (si es necesario) y se mostrarán los detalles de la versión en el archivo artifacts.json.

Si quieres 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 a la actividad.

  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.

Implementa en 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 terminal para detener el resultado de Skaffold.
  2. Ejecuta el siguiente comando para observar cómo tu aplicación funciona en el clúster:
kubectl get all --namespace staging

Deberías ver dos nombres de Pod 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

Cuando 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 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 cómo tu aplicación funciona en el clúster:
kubectl get all --namespace prod

Deberías ver un resultado que contiene 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 la 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?

Sigue obteniendo más información sobre Skaffold:

Limpieza

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