Esta página se ha traducido con Cloud Translation API.

Acelerar el desarrollo en Cloud Code for IntelliJ

Para acelerar el desarrollo local en Cloud Code para IntelliJ, 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:

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

Abre el proyecto en el que quieras definir los módulos.
Abre el archivo skaffold.yaml.

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: {}

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.
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 los módulos y sus dependencias, puedes especificar qué módulos quieres ejecutar en la pestaña Compilación/Implementación cuando selecciones Ejecutar > Editar configuraciones.

Instala las compilaciones de Insiders más recientes.
Ve a Ejecutar > Editar configuraciones y abre la pestaña Compilación/Implementación.
En Configuración de Skaffold, selecciona skaffold.yaml.

Elige una de estas opciones:
- Compilar y desplegar con todos los módulos y dependencias
- Compilar y desplegar con (si hay módulos disponibles) y selecciona los módulos que quieras compilar y desplegar.

La selección se mantendrá en las implementaciones posteriores. Si seleccionas un subconjunto de módulos, Cloud Code mostrará una advertencia sobre la implementación de un subconjunto de módulos y no de todo el sistema.

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

Haz clic en el icono Desarrollar en Kubernetes y, a continuación, en Editar configuraciones para abrir el cuadro de diálogo Configuraciones de ejecución/depuración.
Personaliza tu implementación con las opciones de configuración disponibles.
Si quieres que Cloud Code vuelva a implementar tu aplicación automáticamente después de guardar los cambios, en Modo de monitorización: recompilar y volver a implementar, selecciona Al guardar el archivo. Las nuevas aplicaciones de Kubernetes tienen la opción Bajo demanda seleccionada de forma predeterminada. Para obtener más información sobre los modos del reloj, consulta Modos del reloj.
Si tu aplicación está configurada para usar módulos de Skaffold, puedes seleccionar si quieres compilar o desplegar solo módulos específicos.
Cuando estés conforme con la configuración, haz clic en Aceptar y, a continuación, en el icono Ejecutar.

Siguientes pasos

Usa el clúster minikube integrado de Cloud Code para el desarrollo local.
Depurar una aplicación en Cloud Code
Consulta los detalles sobre la función de sincronización de archivos de Skaffold.

Obtener asistencia

Para enviar comentarios o informar de un problema en tu IDE de IntelliJ, ve a Herramientas > Cloud Code > Ayuda o información > Enviar comentarios o informar de un problema para informar de un problema en GitHub.