Acelerar el desarrollo en Cloud Code para Cloud Shell

Para acelerar el desarrollo local en Cloud Code para Cloud Shell, aprovecha la sincronización de archivos y la recarga en caliente, el despliegue automático al guardar y los módulos de Skaffold para desarrollar partes de una aplicación por separado.

Habilitar la sincronización de archivos y la recarga en caliente de Skaffold

Para mejorar la eficiencia de tu flujo de trabajo de desarrollo local y evitar tener que volver a compilar, implementar y reiniciar tus pods, Skaffold permite copiar los archivos modificados en un contenedor implementado. Esto significa que, cuando hagas cambios en archivos estáticos y de código fuente, podrás ver cómo se aplican en cuestión de segundos, lo que acelera el ciclo de comentarios.

En el caso de los archivos estáticos (como los archivos HTML y CSS), este comportamiento de copia de archivos se denomina sincronización de archivos.

En el caso de los archivos de código fuente, este comportamiento se denomina recarga en caliente y admite los siguientes tipos de archivo:

  • Go: *.go
  • Java: *.java, *.kt, *.scala, *.groovy, *.clj
  • NodeJS: *.js, *.mjs, *.coffee, *.litcoffee, *.json

Con la recarga activa configurada, Skaffold detecta los cambios en los archivos admitidos y los sincroniza con el contenedor en ejecución de tu clúster. Los cambios en los tipos de archivo que no admiten la recarga en caliente activan una recompilación de la imagen y un reinicio del pod.

La sincronización automática de archivos y la recarga activa están habilitadas de forma predeterminada cuando trabajas con Buildpacks como compilador preferido. En otros compiladores, como Docker, puedes especificar una sección sync en el archivo skaffold.yaml del artefacto que quieras personalizar.

La configuración de sincronización puede ser una de las siguientes (en orden de preferencia):

  • auto: Skaffold configura automáticamente la sincronización. (solo para artefactos de Jib y Buildpacks). Este es el valor predeterminado de los buildpacks.
  • infer: los destinos de cada archivo modificado se infieren a partir del compilador.
  • manual: debes especificar los archivos de tu espacio de trabajo local y su destino en el contenedor en ejecución.

En la siguiente sección sync de un archivo skaffold.yaml se especifica una sincronización manual para sincronizar todos los archivos HTML /static-html con la carpeta static de un contenedor:

build:
  artifacts:
    - image: gcr.io/k8s-skaffold/node-example
      context: node
      sync:
        manual:
          - src: 'static-html/*.html'
            dest: static

Para obtener información detallada sobre la sincronización de archivos y la especificación de reglas de sincronización, consulta la guía de Skaffold sobre la sincronización de archivos.

Añadir nuevas funciones al desarrollar en Kubernetes

Después de configurar la sincronización de archivos y la recarga en caliente, inicia un ciclo de iteración y añade más funciones a tu proyecto. Los cambios se implementan en tu clúster de Kubernetes sin detener ni eliminar la implementación, compilar y etiquetar manualmente la imagen, ni actualizar el clúster.

Un ciclo de iteración estándar se parece al siguiente:

  1. Haz un cambio en tu proyecto. Por ejemplo, si usas la aplicación Guestbook de Java de Cloud Code, añade un nuevo endpoint a la clase FrontendController de la siguiente manera:

    1. Abre el archivo FrontendController.java de src/main/java/cloudcode/guestbook/frontend y añade lo siguiente:

      @RequestMapping("/greeting")
@ResponseBody
public String greeting(@RequestParam(value="name", defaultValue="World") String name) {
   return String.format("Hello from Kubernetes with IntelliJ, %s!", name);
}

    2. Añade las importaciones necesarias para las nuevas anotaciones, RequestMapping y ResponseBody.

  2. Guarda los cambios (Ctrl/Cmd+S) o compila el proyecto.

    Puedes ver el progreso y los registros de implementación en la ventana de la consola. Una vez que se hayan implementado los cambios, confirme las actualizaciones.

  3. Para finalizar la sesión de desarrollo continuo, haz clic en el icono Detener.

    Cloud Code elimina todos los recursos de Kubernetes utilizados en la sesión de desarrollo.

Desarrollar aplicaciones de microservicios con configuraciones de Skaffold

Al desarrollar aplicaciones de microservicios, puede ser útil trabajar en secciones independientes para simplificar la depuración y la implementación.

Puedes desarrollar y depurar partes de tu aplicación de forma independiente dividiéndola en módulos de Skaffold. Por ejemplo, la muestra Bank of Anthos es una aplicación que contiene diez microservicios. En el archivo de ejemplo skaffold.yaml se agrupan estos servicios en cinco módulos de Skaffold llamados setup, db, frontend, backend y loadgenerator.

Definir módulos de Skaffold y dependencias de configuración

Para definir módulos de Skaffold y dependencias de configuración, haz lo siguiente:

  1. Abre el proyecto en el que quieras definir los módulos.

  2. Abre el archivo skaffold.yaml.

  3. Si tu archivo skaffold.yaml tiene varias configuraciones, para convertir una configuración en un módulo de Skaffold, especifica la siguiente línea:

    metadata:
  name: MODULE_NAME_1

    Por ejemplo, en Bank of Anthos skaffold.yaml, el módulo db define las implementaciones de la base de datos:

    apiVersion: skaffold/v3
kind: Config
metadata:
  name: db # module defining database deployments
requires:
- configs:
  - setup
build:
  artifacts:
  - image: accounts-db
    context: src/accounts-db
  - image: ledger-db
    context: src/ledger-db
manifests:
  rawYaml:
  - dev-kubernetes-manifests/accounts-db.yaml
  - dev-kubernetes-manifests/ledger-db.yaml
deploy:
  kubectl: {}

  4. En las configuraciones que dependen de que se implemente otra configuración antes de que se pueda implementar la configuración actual, debes añadir la configuración a tus dependencias. Para especificar una dependencia de configuración, añade una lista configs a la sección requires del archivo skaffold.yaml.

    Por ejemplo, el archivo skaffold.yaml de Bank of Anthos incluye la dependencia de configuración setup.

    Para definir una dependencia, añade lo siguiente al archivo skaffold.yaml, donde DEPENDENCY_NAME es el nombre de la dependencia.

    requires:
    - configs: DEPENDENCY_NAME

    Las configuraciones que se incluyan de esta forma pueden hacer referencia a las dependencias definidas en el mismo archivo u otros archivos skaffold.yaml del proyecto actual.

  5. Prueba las dependencias de tu configuración creando cada uno de los módulos de Skaffold por separado para asegurarte de que se implementan con sus dependencias. Para ello, sigue los pasos que se indican en Crear módulos de Skaffold específicos y sus dependencias.

Compilar módulos de Skaffold específicos y sus dependencias

Una vez que hayas definido tus módulos y sus dependencias, puedes especificar qué módulos quieres ejecutar con código en la nube en tu archivo launch.json.

Si tu proyecto no tiene definido un archivo launch.json, cuando ejecutes Cloud Code: Run on Kubernetes (Cloud Code: ejecutar en Kubernetes) o Cloud Code: Debug on Kubernetes (Cloud Code: depurar en Kubernetes), se te pedirá que selecciones los módulos que quieras compilar:

  1. Abre la paleta de comandos (Ctrl/Cmd+Shift+P) y, a continuación, ejecuta Cloud Code: Run on Kubernetes (Cloud Code: ejecutar en Kubernetes).
  2. Haz clic en Seleccionar módulos.
  3. Elige los módulos que quieras implementar y haz clic en Aceptar. Cada módulo se compila con sus dependencias.
  4. Cuando se te pida, elige un registro de imágenes y pulsa Enter.

Si tu proyecto tiene un launch.json, sigue estos pasos para elegir los módulos de Skaffold que quieres compilar:

  1. Abre el archivo launch.json de tu proyecto.

  2. Edita la configuración de lanzamiento para añadir la opción skaffoldFlags con una lista delimitada por comas de modules que se van a compilar. Si se omite skaffoldFlags, se compilan todos los módulos.

      {
    "name": "Run on Kubernetes",
    "type": "cloudcode.kubernetes",
    "request": "launch",
    "skaffoldConfig": "${workspaceFolder}/skaffold.yaml",
    "skaffoldFlags": {
       "modules": ["MODULE_NAME_2,MODULE_NAME_2"],
    "watch": true,
    "cleanUp": true,
    }
  }

  3. Ejecuta la configuración de inicio que has editado.

Desarrollo continuo en Kubernetes

Una vez que hayas configurado el destino de ejecución con las opciones que quieras, puedes ejecutar tu aplicación de forma normal o iniciar un ciclo de iteración de desarrollo en tu IDE para propagar los cambios que hayas hecho en el código fuente y las dependencias a tu aplicación activa.

El destino de ejecución Ejecutar en Kubernetes inicia el ciclo de desarrollo en tu clúster de Kubernetes. Después de iniciar el ciclo de desarrollo, Cloud Code, mediante Skaffold, crea una imagen del proyecto, la etiqueta, la envía al repositorio configurado y usa kubectl para implementar los archivos de manifiesto de Kubernetes del proyecto.

  1. Personaliza tu implementación con las opciones de configuración disponibles.
  2. Si tu aplicación está configurada para usar módulos de Skaffold, puedes seleccionar módulos específicos para compilar o implementar.
  3. Abre la paleta de comandos (pulsa Ctrl/Cmd + Shift + P) y, a continuación, ejecuta el comando Cloud Code: Run on Kubernetes (Cloud Code: Ejecutar en Kubernetes).
  4. Confirma si quieres usar el contexto de Kubernetes actual para ejecutar la aplicación (o cambia a otro). Para obtener más información sobre cómo configurar un contexto de Kubernetes, consulta Configuración.

  5. Si has elegido un clúster remoto como contexto, cuando se te pida, elige un registro de imágenes al que enviar las imágenes. Si tu proyecto tiene la API de Artifact Registry habilitada y al menos un repositorio de Artifact Registry, puedes buscar y seleccionar un repositorio de Artifact Registry.

    Cloud Code compila tus contenedores, los envía al registro, aplica las configuraciones de Kubernetes al clúster y espera a que se implementen.

Siguientes pasos