Acelera el desarrollo en Cloud Code para Cloud Shell

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

A fin de acelerar tu desarrollo local en Cloud Code para Cloud Shell, aprovecha la sincronización de archivos y la recarga en caliente, la implementación automática en guardado y usa 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 admite la copia de archivos modificados en un contenedor implementado. Esto significa que, cuando realizas cambios en los archivos estáticos y del código fuente, puedes ver que los cambios se aplican en segundos, lo que genera un ciclo de reacción acelerado.

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

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

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

Cuando se configura la recarga en caliente, Skaffold detecta los cambios en los archivos compatibles y los sincroniza con el contenedor en ejecución del clúster. Los cambios en los tipos de archivo que no admiten la recarga en caliente activan la recompilación de una imagen y el reinicio del pod.

La sincronización automática de archivos y la recarga en caliente están habilitadas de forma predeterminada cuando trabajas con Buildpacks como tu compilador preferido. Para otros compiladores como Docker, puedes especificar una sección sync en tu archivo skaffold.yaml para el artefacto que estás personalizando.

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 Jib y Buildpacks). Esta es la configuración predeterminada de los paquetes de compilación.
  • infer: Los destinos de cada archivo modificado se infieren del compilador.
  • manual: Debes especificar los archivos en tu lugar de trabajo local y su destino en el contenedor en ejecución.

En la siguiente sección sync de muestra en un archivo skaffold.yaml, se especifica una sincronización de manual para sincronizar todos los archivos HTML /static-html con la carpeta static en 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.

Agrega funciones nuevas cuando desarrolles en Kubernetes

Después de configurar la sincronización de archivos y la recarga en caliente, inicia un ciclo de iteración y agrega más funciones a tu proyecto. Los cambios se implementan en tu clúster de Kubernetes sin detener y quitar la implementación, compilar ni 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 app de libro de visitas de Java para Cloud Code, agrega un extremo nuevo a la clase FrontendController de la siguiente manera:

    1. Abre el archivo FrontendController.java de src/main/java/cloudcode/guestbook/frontend y agrega 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. Agrega las importaciones necesarias para las anotaciones nuevas, RequestMapping y ResponseBody.

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

    Puedes mirar el progreso y los registros de la implementación en la ventana de la consola. Después de implementar los cambios, confirme las actualizaciones.

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

    Cloud Code borra todos los recursos de Kubernetes que se usaron para la sesión de desarrollo.

Desarrolla aplicaciones de microservicios con las configuraciones de Skaffold

Cuando desarrollas aplicaciones de microservicios, puede ser útil trabajar en secciones separadas de forma independiente para simplificar la depuración y la implementación.

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

Define los módulos de Skaffold y las 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 quieres 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 el skaffold.yaml del banco de Anthos, el módulo db define las implementaciones de bases de datos:

    skaffold.yaml 
    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. Para configuraciones que se basan en otra configuración implementada antes de que se pueda implementar la configuración actual, debes agregar la configuración a tus dependencias. Para especificar una dependencia de configuración, agrega una lista configs a la sección requires de tu archivo skaffold.yaml.

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

    Para definir una dependencia, agrega lo siguiente a tu archivo skaffold.yaml, en el que DEPENDENCY_NAME es el nombre de tu dependencia.

    requires:
    - configs: DEPENDENCY_NAME

    Las configuraciones que se enumeran de esta manera pueden hacer referencia a dependencias definidas en el mismo archivo o en otros archivos skaffold.yaml del proyecto actual.

  5. A fin de probar las dependencias de configuración, compila cada uno de los módulos de Skaffold por separado para asegurarte de que se implementen con sus dependencias mediante los pasos que se indican en Cómo compilar módulos de Skaffold específicos y sus dependencias.

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

Después de definir tus módulos y sus dependencias, puedes especificar cuáles quieres ejecutar con el código en la nube en tu archivo launch.json.

Si tu proyecto no tiene un archivo launch.json definido, cuando ejecutes Cloud Code: Run on Kubernetes o Cloud Code: Debug on Kubernetes, se te solicitará que selecciones los módulos para compilar:

  1. Abre la paleta de comandos (Ctrl/Cmd+Shift+P) y, luego, ejecuta Cloud Code: Ejecutar en Kubernetes.
  2. Haz clic en Seleccionar módulos.
  3. Elija los módulos que desea implementar y, luego, haga clic en OK. Cada módulo se compila con sus dependencias.
  4. Cuando se te solicite, elige un registro de imágenes y, luego, presiona 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 inicio para agregar la opción skaffoldFlags con una lista delimitada por comas de modules a fin de 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 editaste.

Desarrollo continuo en Kubernetes

Una vez que hayas configurado tu objetivo de ejecución con las opciones que desees, puedes optar por una ejecución regular de tu aplicación o iniciar un ciclo de iteración de desarrollo en tu IDE para propagar cualquier cambio realizado en la fuente y dependencias a tu aplicación activa.

El objetivo de ejecución Run on Kubernetes (Ejecutar en Kubernetes) inicia el ciclo de desarrollo en tu clúster de Kubernetes. Después de iniciar el ciclo de desarrollo, Cloud Code usa Skaffold para compilar una imagen del proyecto y, luego, la etiqueta, la envía al repositorio configurado y usa kubectl a fin de implementar los manifiestos de Kubernetes del proyecto.

  1. Personaliza la implementación mediante 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 (presiona Ctrl/Cmd+Shift+P) y, luego, ejecuta el comando Cloud Code: Ejecutar en Kubernetes.
  4. Confirma si deseas usar el contexto de Kubernetes actual para ejecutar la aplicación (o cambia a una preferida). Para obtener más información sobre cómo establecer un contexto de Kubernetes, consulta cómo establecer la configuración.

  5. Si eliges un clúster remoto como contexto, cuando se te solicite, elige un registro de imagen al que se envíen las imágenes. Si usas Container Registry, puedes navegar a un registro existente o especificar el nombre de un registro que se creará. Si tu proyecto tiene la API de Artifact Registry habilitada y al menos un repositorio de Artifact Registry, puedes explorar y seleccionar un repositorio de Artifact Registry existente.

    A continuación, Cloud Code compila los contenedores, los envía al registro, aplica las configuraciones de Kubernetes al clúster y espera el lanzamiento.

¿Qué sigue?